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


#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

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

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



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

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

#endif

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

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

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


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

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


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

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

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

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

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

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


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

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

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

#ifdef __cplusplus
}
#endif


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

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

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

/* Common SWIG API */

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

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

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

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

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

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

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

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


/* Runtime API */

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

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


/* Runtime API implementation */

/* Error manipulation */

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

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

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

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

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

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

#else

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

#endif

/* Append a value to the result obj */

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

/* Unpack the argument tuple */

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

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

/* -----------------------------------------------------------------------------
 * 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;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
      data->delargs = !(flags & (METH_O));
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

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

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

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


#ifdef SWIGPYTHON_BUILTIN

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

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

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

#endif

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

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

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

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

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

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

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

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


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

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

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

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

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

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

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

      PyErr_Restore(type, value, traceback);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

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

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

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

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyPacked",                       /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#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 (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 0;
    }
    res = SWIG_OK;
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

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

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

/* Convert a packed pointer value */

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

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

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

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      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 {
            Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
          }
        }
      }
      Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME 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;
    }
    return PyDict_SetItem(dict, SWIG_This(), swig_this);
  }
#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) {
      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
      newobj->dict = 0;
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

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

/* Create a new packed object */

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


#ifdef __cplusplus
}
#endif



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

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



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

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

#ifdef __cplusplus
}
#endif


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

#define SWIGVERSION 0x040002 
#define SWIG_VERSION SWIGVERSION


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


#include <stdexcept>


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

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

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

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


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


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


#ifdef barrier
#undef barrier
#endif


#include <ql/quantlib.hpp>

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

#ifdef BOOST_MSVC
#ifdef QL_ENABLE_THREAD_SAFE_OBSERVER_PATTERN
#define BOOST_LIB_NAME boost_thread
#include <boost/config/auto_link.hpp>
#undef BOOST_LIB_NAME
#define BOOST_LIB_NAME boost_system
#include <boost/config/auto_link.hpp>
#undef BOOST_LIB_NAME
#endif
#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 call 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 call 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


#if PY_VERSION_HEX < 0x02010000
    #error Python version 2.1.0 or later is required
#endif


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


#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_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#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>


// 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(std::vector< unsigned int > *self,PySliceObject *slice,std::vector< unsigned int,std::allocator< unsigned int > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(std::vector< unsigned int > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(std::vector< unsigned int > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< unsigned int >::value_type const &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1(std::vector< unsigned int > const *self,std::vector< unsigned int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_2(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< unsigned int >::value_type std_vector_Sl_unsigned_SS_int_Sg__pop(std::vector< unsigned int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< unsigned int,std::allocator< unsigned int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__append(std::vector< unsigned int > *self,std::vector< unsigned int >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator first,std::vector< unsigned int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos,std::vector< unsigned int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos,std::vector< unsigned int >::size_type n,std::vector< unsigned int >::value_type const &x){ self->insert(pos, n, x); }

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

SWIGINTERN int
SWIG_AsVal_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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }

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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<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 <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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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::Exercise;


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


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::Observer;
using QuantLib::Observable;


// 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 extractArray(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");
            }
        }

typedef QuantLib::LexicographicalView<Array::iterator>
    DefaultLexicographicalView;
typedef QuantLib::LexicographicalView<Array::iterator>::y_iterator
    DefaultLexicographicalViewColumn;

SWIGINTERN Real DefaultLexicographicalViewColumn___getitem__(DefaultLexicographicalViewColumn *self,Size i){
            return (*self)[i];
        }
SWIGINTERN void DefaultLexicographicalViewColumn___setitem__(DefaultLexicographicalViewColumn *self,Size i,Real x){
            (*self)[i] = x;
        }
SWIGINTERN DefaultLexicographicalView *new_DefaultLexicographicalView(Array &a,Size xSize){
            return new DefaultLexicographicalView(a.begin(),a.end(),xSize);
        }
SWIGINTERN std::string DefaultLexicographicalView___str__(DefaultLexicographicalView *self){
            std::ostringstream s;
            for (Size j=0; j<self->ySize(); j++) {
                s << "\n";
                for (Size i=0; i<self->xSize(); i++) {
                    if (i != 0)
                        s << ",";
                    Array::value_type value = (*self)[i][j];
                    s << value;
                }
            }
            s << "\n";
            return s.str();
        }
SWIGINTERN DefaultLexicographicalViewColumn DefaultLexicographicalView___getitem__(DefaultLexicographicalView *self,Size i){
            return (*self)[i];
        }

typedef QuantLib::Matrix::row_iterator MatrixRow;
using QuantLib::outerProduct;
using QuantLib::transpose;
using QuantLib::SVD;

SWIGINTERN Real MatrixRow___getitem__(MatrixRow *self,Size i){
            return (*self)[i];
        }
SWIGINTERN void MatrixRow___setitem__(MatrixRow *self,Size i,Real x){
            (*self)[i] = x;
        }
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,Size i){
            return (*self)[i];
        }
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::Disposable;
using QuantLib::BiCGstab;
using QuantLib::GMRES;


Disposable<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_);    
    }
    
    Disposable<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;
using QuantLib::Disposable;


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;
    }
    Disposable<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::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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::Calendar;


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


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

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::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::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::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);
    }

// 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::BackwardFlat;
using QuantLib::ForwardFlat;
using QuantLib::Linear;
using QuantLib::LogLinear;
using QuantLib::Cubic;
using QuantLib::Bicubic;
using QuantLib::ConvexMonotone;

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

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

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

class DefaultLogCubic : public QuantLib::LogCubic {
  public:
    DefaultLogCubic()
    : QuantLib::LogCubic(QuantLib::CubicInterpolation::Kruger) {}
};

class MonotonicLogCubic : public QuantLib::LogCubic {
  public:
    MonotonicLogCubic()
    : QuantLib::LogCubic(QuantLib::CubicInterpolation::Spline, true,
                         QuantLib::CubicInterpolation::SecondDerivative, 0.0,
                         QuantLib::CubicInterpolation::SecondDerivative, 0.0) {}
};

class KrugerLog : public QuantLib::LogCubic {
  public:
    KrugerLog()
    : QuantLib::LogCubic(QuantLib::CubicInterpolation::Kruger, false,
                         QuantLib::CubicInterpolation::SecondDerivative, 0.0,
                         QuantLib::CubicInterpolation::SecondDerivative, 0.0) {}
};


// 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,
                          bool betaIsFixed,
                          bool nuIsFixed,
                          bool rhoIsFixed,
                          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::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 QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure;


using QuantLib::FlatForward;


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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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 *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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::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::Eonia;


using QuantLib::Sonia;


using QuantLib::FedFunds;


using QuantLib::Nzocr;


using QuantLib::Sofr;


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::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::LocalConstantVol;


using QuantLib::LocalVolSurface;


using QuantLib::NoExceptLocalVolSurface;


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, NullCalendar(), Following,
                                                dates, lengths, vols, dayCounter,
                                                flatExtrapolation, type, shifts);
        }

using QuantLib::SabrSmileSection;


using QuantLib::SwaptionVolatilityCube;
using QuantLib::SwaptionVolCube1;
using QuantLib::SwaptionVolCube2;

SWIGINTERN ext::shared_ptr< SabrSmileSection > SwaptionVolCube1_smileSection__SWIG_0(SwaptionVolCube1 *self,Time optionTime,Time swapLength,bool extr=false){
            SwaptionVolatilityStructure* base = dynamic_cast<SwaptionVolatilityStructure*>(self);
            return ext::dynamic_pointer_cast<SabrSmileSection>(base->smileSection(optionTime, swapLength, extr));
        }
SWIGINTERN ext::shared_ptr< SabrSmileSection > SwaptionVolCube1_smileSection__SWIG_2(SwaptionVolCube1 *self,Period const &optionTenor,Period const &swapTenor,bool extr=false){
            SwaptionVolatilityStructure* base = dynamic_cast<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::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::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::CashFlow;


  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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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); }

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


    ext::shared_ptr<IndexedCashFlow> as_indexed_cashflow(const ext::shared_ptr<CashFlow>& cf) {
        return boost::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);
    }


using QuantLib::CappedFlooredCoupon;


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


using QuantLib::IborCouponPricer;
using QuantLib::BlackIborCouponPricer;


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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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); }

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) {
    return QuantLib::FixedRateLeg(schedule)
        .withNotionals(nominals)
        .withCouponRates(couponRates,dayCount)
        .withPaymentAdjustment(paymentAdjustment)
        .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) {
    return QuantLib::IborLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth);
}


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) {
    return QuantLib::OvernightLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withTelescopicValueDates(telescopicValueDates);
}


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


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 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::VanillaSwap;
using QuantLib::Swaption;
using QuantLib::CalibrationHelper;
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< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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); }

  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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::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::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::Parameter;
using QuantLib::ConstantParameter;
using QuantLib::NullParameter;
using QuantLib::PiecewiseConstantParameter;


using QuantLib::Payoff;
using QuantLib::TypePayoff;
using QuantLib::StrikedTypePayoff;


using QuantLib::Option;
using QuantLib::Barrier;


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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::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 std::pair< Real,Real > AnalyticHestonEngine_chF(AnalyticHestonEngine const *self,Real real,Real imag,Time t){
            const std::complex<Real> tmp 
                = self->chF(std::complex<Real>(real, imag), t);
            return std::pair<Real, Real>(tmp.real(), tmp.imag());
        }

using QuantLib::COSHestonEngine;


using QuantLib::ExponentialFittingHestonEngine;


using QuantLib::AnalyticPTDHestonEngine;


using QuantLib::BatesModel;


using QuantLib::BatesEngine;


using QuantLib::IntegralEngine;


using QuantLib::CrankNicolson;
using QuantLib::FDBermudanEngine;
using QuantLib::FDEuropeanEngine;


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::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::PolynomType polynomType=LsmBasisSystem::Monomial,int nCalibrationSamples=2048,boost::optional< bool > antitheticVariateCalibration=boost::none,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::PolynomType polynomType=LsmBasisSystem::Monomial,int nCalibrationSamples=2048,boost::optional< bool > antitheticVariateCalibration=boost::none,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);
        }

using QuantLib::FDAmericanEngine;
using QuantLib::FDShoutEngine;


using QuantLib::ContinuousArithmeticAsianLevyEngine;


using QuantLib::FdBlackScholesAsianEngine;


using QuantLib::BaroneAdesiWhaleyApproximationEngine;


using QuantLib::BjerksundStenslandApproximationEngine;


using QuantLib::JuQuadraticApproximationEngine;


using QuantLib::AnalyticDigitalAmericanEngine;


using QuantLib::AnalyticDigitalAmericanKOEngine;


using QuantLib::DividendVanillaOption;


using QuantLib::AnalyticDividendEuropeanEngine;


using QuantLib::FDDividendEuropeanEngine;
using QuantLib::FDDividendAmericanEngine;


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


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::FdmSchemeDesc;


using QuantLib::FdmQuantoHelper;


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

SWIGINTERN ext::shared_ptr< FdBlackScholesVanillaEngine > FdBlackScholesVanillaEngine_make(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,ext::shared_ptr< FdmQuantoHelper > const &quantoHelper=ext::shared_ptr< FdmQuantoHelper >(),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){
            return ext::shared_ptr<FdBlackScholesVanillaEngine>(
                new FdBlackScholesVanillaEngine(process, quantoHelper, tGrid, xGrid,
                                                dampingSteps, schemeDesc,
                                                localVol, illegalLocalVolOverwrite,
                                                cashDividendModel));
        }
SWIGINTERN ext::shared_ptr< FdHestonVanillaEngine > FdHestonVanillaEngine_make(ext::shared_ptr< HestonModel > const &model,ext::shared_ptr< FdmQuantoHelper > const &quantoHelper=ext::shared_ptr< FdmQuantoHelper >(),Size tGrid=100,Size xGrid=100,Size vGrid=50,Size dampingSteps=0,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer(),ext::shared_ptr< LocalVolTermStructure > const &leverageFct=ext::shared_ptr< LocalVolTermStructure >(),Real const mixingFactor=1.0){
            return ext::shared_ptr<FdHestonVanillaEngine>(
                new FdHestonVanillaEngine(model, quantoHelper, tGrid, xGrid, vGrid,
                                          dampingSteps, schemeDesc, leverageFct, mixingFactor));
        }

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


using QuantLib::FdSabrVanillaEngine;


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


using QuantLib::AnalyticBinaryBarrierEngine;


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


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


using QuantLib::BlackCalculator;


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


using QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine;


using QuantLib::AnalyticDiscreteGeometricAveragePriceAsianEngine;


using QuantLib::AnalyticDiscreteGeometricAverageStrikeAsianEngine;


using QuantLib::MCDiscreteArithmeticAPEngine;
using QuantLib::MCDiscreteArithmeticASEngine;
using QuantLib::MCDiscreteGeometricAPEngine;

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

using QuantLib::VarianceGammaEngine;


using QuantLib::FFTVarianceGammaEngine;


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


using QuantLib::QuantoDoubleBarrierOption;


using QuantLib::AnalyticDoubleBarrierEngine;


using QuantLib::FdHestonDoubleBarrierEngine;


using QuantLib::WulinYongDoubleBarrierEngine;


using QuantLib::VannaVolgaBarrierEngine;
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::VannaVolgaDoubleBarrierEngine;


using QuantLib::AnalyticDoubleBarrierBinaryEngine;


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


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

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::SpreadOption;
using QuantLib::KirkSpreadOptionEngine;


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::PolynomType 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::PolynomType 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::Callability;
using QuantLib::SoftCallability;
typedef Callability::Price CallabilityPrice;
using QuantLib::CallabilitySchedule;


  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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::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;

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,
                                             boost::none,
                                             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;


using QuantLib::EUHICP;


using QuantLib::EUHICPXT;


using QuantLib::FRHICP;


using QuantLib::UKRPI;


using QuantLib::USCPI;


using QuantLib::ZACPI;


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;


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


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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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); }
SWIGINTERN ZeroCouponInflationSwapHelper *new_ZeroCouponInflationSwapHelper__SWIG_0(Handle< Quote > const &quote,Period const &lag,Date const &maturity,Calendar const &calendar,BusinessDayConvention bcd,DayCounter const &dayCounter,ext::shared_ptr< ZeroInflationIndex > const &index,Handle< YieldTermStructure > const &nominalTS=Handle< YieldTermStructure >()){

            return new ZeroCouponInflationSwapHelper(quote,lag,maturity,
                                                     calendar,bcd,
                                                     dayCounter,index,
                                                     nominalTS);
        }
SWIGINTERN YearOnYearInflationSwapHelper *new_YearOnYearInflationSwapHelper__SWIG_0(Handle< Quote > const &quote,Period const &lag,Date const &maturity,Calendar const &calendar,BusinessDayConvention bdc,DayCounter const &dayCounter,ext::shared_ptr< YoYInflationIndex > const &index,Handle< YieldTermStructure > const &nominalTS=Handle< YieldTermStructure >()){
            return new YearOnYearInflationSwapHelper(quote,lag,maturity,
                                                     calendar,bdc,
                                                     dayCounter,index,
                                                     nominalTS);
        }

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



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



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;
using QuantLib::ZeroCouponBond;
using QuantLib::FixedRateBond;
using QuantLib::AmortizingFixedRateBond;
using QuantLib::FloatingRateBond;
using QuantLib::AmortizingFloatingRateBond;
using QuantLib::DiscountingBondEngine;


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


SWIGINTERN ext::shared_ptr< FixedRateBond > FixedRateBond_from_rates(Integer settlementDays,Real faceAmount,Schedule const &schedule,std::vector< Rate,std::allocator< Rate > > const &coupons,DayCounter const &paymentDayCounter,BusinessDayConvention paymentConvention=QuantLib::Following,Real redemption=100.0,Date issueDate=Date(),Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false){
            return ext::shared_ptr<FixedRateBond>(
                new FixedRateBond(settlementDays, faceAmount, schedule, coupons,
                                  paymentDayCounter, paymentConvention,
                                  redemption, issueDate, paymentCalendar,
                                  exCouponPeriod, exCouponCalendar,
                                  exCouponConvention, exCouponEndOfMonth));
        }
SWIGINTERN ext::shared_ptr< FixedRateBond > FixedRateBond_from_interest_rates(Integer settlementDays,Real faceAmount,Schedule const &schedule,std::vector< InterestRate,std::allocator< InterestRate > > const &coupons,BusinessDayConvention paymentConvention=Following,Real redemption=100.0,Date const &issueDate=Date(),Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false){
            return ext::shared_ptr<FixedRateBond>(
                new FixedRateBond(settlementDays, faceAmount, schedule, coupons,
                                  paymentConvention, redemption,
                                  issueDate, paymentCalendar,
                                  exCouponPeriod, exCouponCalendar,
                                  exCouponConvention, exCouponEndOfMonth));
        }
SWIGINTERN ext::shared_ptr< FixedRateBond > FixedRateBond_from_date_info(Integer settlementDays,Calendar const &couponCalendar,Real faceAmount,Date const &startDate,Date const &maturityDate,Period const &tenor,std::vector< Rate,std::allocator< Rate > > const &coupons,DayCounter const &accrualDayCounter,BusinessDayConvention accrualConvention=QuantLib::Following,BusinessDayConvention paymentConvention=QuantLib::Following,Real redemption=100.0,Date const &issueDate=Date(),Date const &stubDate=Date(),DateGeneration::Rule rule=QuantLib::DateGeneration::Backward,bool endOfMonth=false,Calendar const &paymentCalendar=Calendar(),Period const &exCouponPeriod=Period(),Calendar const &exCouponCalendar=Calendar(),BusinessDayConvention const exCouponConvention=Unadjusted,bool exCouponEndOfMonth=false){
            return ext::shared_ptr<FixedRateBond>(
                new FixedRateBond(settlementDays, couponCalendar, faceAmount,
                                  startDate, maturityDate, tenor,
                                  coupons, accrualDayCounter, accrualConvention,
                                  paymentConvention, redemption, issueDate,
                                  stubDate, rule, endOfMonth, paymentCalendar,
                                  exCouponPeriod, exCouponCalendar,
                                  exCouponConvention, exCouponEndOfMonth));
        }

using QuantLib::CmsRateBond;


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


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::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::Dividend;


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


  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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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::ConvertibleZeroCouponBond;
using QuantLib::ConvertibleFixedCouponBond;
using QuantLib::ConvertibleFloatingRateBond;
using QuantLib::BinomialConvertibleEngine;


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;


  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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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);
    }


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


using QuantLib::PiecewiseYieldCurve;


struct _IterativeBootstrap {
    double accuracy, minValue, maxValue;
    _IterativeBootstrap(double accuracy = Null<double>(),
                        double minValue = Null<double>(),
                        double maxValue = Null<double>())
    : accuracy(accuracy), minValue(minValue), maxValue(maxValue) {}
};


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 >(),Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseFlatForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_6(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 >(),Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, BackwardFlat(),
                            PiecewiseFlatForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseFlatForward(referenceDate, instruments, dayCounter, BackwardFlat(),
                            PiecewiseFlatForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_13(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){
            return new PiecewiseFlatForward(settlementDays, calendar, instruments, dayCounter,
                            BackwardFlat(), PiecewiseFlatForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,LogLinear const &i=LogLinear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogLinearDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseLogLinearDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_6(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 >(),Real accuracy=1.0e-12,LogLinear const &i=LogLinear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogLinearDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, LogLinear(),
                            PiecewiseLogLinearDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseLogLinearDiscount(referenceDate, instruments, dayCounter, LogLinear(),
                            PiecewiseLogLinearDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_13(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){
            return new PiecewiseLogLinearDiscount(settlementDays, calendar, instruments, dayCounter,
                            LogLinear(), PiecewiseLogLinearDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseLinearForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_6(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 >(),Real accuracy=1.0e-12,Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, Linear(),
                            PiecewiseLinearForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseLinearForward(referenceDate, instruments, dayCounter, Linear(),
                            PiecewiseLinearForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_13(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){
            return new PiecewiseLinearForward(settlementDays, calendar, instruments, dayCounter,
                            Linear(), PiecewiseLinearForward::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseLinearZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_6(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 >(),Real accuracy=1.0e-12,Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, Linear(),
                            PiecewiseLinearZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseLinearZero(referenceDate, instruments, dayCounter, Linear(),
                            PiecewiseLinearZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_13(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){
            return new PiecewiseLinearZero(settlementDays, calendar, instruments, dayCounter,
                            Linear(), PiecewiseLinearZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,Cubic const &i=Cubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseCubicZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseCubicZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_6(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 >(),Real accuracy=1.0e-12,Cubic const &i=Cubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseCubicZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, Cubic(),
                            PiecewiseCubicZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseCubicZero(referenceDate, instruments, dayCounter, Cubic(),
                            PiecewiseCubicZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_13(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){
            return new PiecewiseCubicZero(settlementDays, calendar, instruments, dayCounter,
                            Cubic(), PiecewiseCubicZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,MonotonicLogCubic const &i=MonotonicLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseLogCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_6(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 >(),Real accuracy=1.0e-12,MonotonicLogCubic const &i=MonotonicLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, MonotonicLogCubic(),
                            PiecewiseLogCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseLogCubicDiscount(referenceDate, instruments, dayCounter, MonotonicLogCubic(),
                            PiecewiseLogCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_13(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){
            return new PiecewiseLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            MonotonicLogCubic(), PiecewiseLogCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseSplineCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseSplineCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_6(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 >(),Real accuracy=1.0e-12,SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseSplineCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, SplineCubic(),
                            PiecewiseSplineCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseSplineCubicDiscount(referenceDate, instruments, dayCounter, SplineCubic(),
                            PiecewiseSplineCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_13(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){
            return new PiecewiseSplineCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            SplineCubic(), PiecewiseSplineCubicDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,Kruger const &i=Kruger(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseKrugerZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_6(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 >(),Real accuracy=1.0e-12,Kruger const &i=Kruger(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, Kruger(),
                            PiecewiseKrugerZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseKrugerZero(referenceDate, instruments, dayCounter, Kruger(),
                            PiecewiseKrugerZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_13(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){
            return new PiecewiseKrugerZero(settlementDays, calendar, instruments, dayCounter,
                            Kruger(), PiecewiseKrugerZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,KrugerLog const &i=KrugerLog(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerLogDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseKrugerLogDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_6(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 >(),Real accuracy=1.0e-12,KrugerLog const &i=KrugerLog(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerLogDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, KrugerLog(),
                            PiecewiseKrugerLogDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseKrugerLogDiscount(referenceDate, instruments, dayCounter, KrugerLog(),
                            PiecewiseKrugerLogDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_13(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){
            return new PiecewiseKrugerLogDiscount(settlementDays, calendar, instruments, dayCounter,
                            KrugerLog(), PiecewiseKrugerLogDiscount::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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 >(),Real accuracy=1.0e-12,ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            accuracy, i, PiecewiseConvexMonotoneZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_6(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 >(),Real accuracy=1.0e-12,ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, accuracy, ConvexMonotone(),
                            PiecewiseConvexMonotoneZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_12(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseConvexMonotoneZero(referenceDate, instruments, dayCounter, ConvexMonotone(),
                            PiecewiseConvexMonotoneZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_13(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){
            return new PiecewiseConvexMonotoneZero(settlementDays, calendar, instruments, dayCounter,
                            ConvexMonotone(), PiecewiseConvexMonotoneZero::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatHazardRate(referenceDate, instruments, dayCounter, accuracy, i,
                            PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_4(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &instruments,DayCounter const &dayCounter,Real accuracy=1.0e-12,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatHazardRate(settlementDays, calendar, instruments, dayCounter,
                            accuracy, i, PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_8(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, 1e-12,
                            BackwardFlat(), PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_9(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, 1e-12,
                            BackwardFlat(), PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

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){
            boost::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::conversionType = type;
        }
SWIGINTERN void Money_setBaseCurrency(Currency const &c){
            Money::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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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(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));
        }
SWIGINTERN Array FdmMesherComposite_locations(FdmMesherComposite const *self,Size direction){
            return self->locations(direction);
        }
SWIGINTERN ext::shared_ptr< FdmLinearOpLayout > FdmMesherComposite_layout(FdmMesherComposite *self){
            const std::vector<ext::shared_ptr<Fdm1dMesher> >& meshers =
                self->getFdm1dMeshers();
                
            std::vector<Size> dim(meshers.size());
            
            for (Size i=0; i < dim.size(); ++i)
                dim[i] = meshers[i]->size();
                
            return ext::make_shared<FdmLinearOpLayout>(dim);
        }

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


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

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

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

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

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

    Disposable<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:
    Disposable<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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< 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 ext::shared_ptr<YieldTermStructure> FittedBondDiscountCurvePtr;
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::InterpolatedForwardCurve;


using QuantLib::Forward;


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


using QuantLib::Position;
using QuantLib::ForwardRateAgreement;


using QuantLib::Gaussian1dModel;


using QuantLib::Gsr;
using QuantLib::MarkovFunctional;


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;

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);
        }
SWIGINTERN Real GaussLaguerreIntegration___call__(GaussLaguerreIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussHermiteIntegration___call__(GaussHermiteIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussJacobiIntegration___call__(GaussJacobiIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussHyperbolicIntegration___call__(GaussHyperbolicIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussLegendreIntegration___call__(GaussLegendreIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussChebyshevIntegration___call__(GaussChebyshevIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussChebyshev2ndIntegration___call__(GaussChebyshev2ndIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }
SWIGINTERN Real GaussGegenbauerIntegration___call__(GaussGegenbauerIntegration *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return (*self)(f);
        }

using QuantLib::Sample;

using QuantLib::LecuyerUniformRng;
using QuantLib::KnuthUniformRng;
using QuantLib::MersenneTwisterUniformRng;

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;

typedef QuantLib::LowDiscrepancy::ursg_type
    UniformLowDiscrepancySequenceGenerator;

using QuantLib::InverseCumulativeRsg;

typedef QuantLib::PseudoRandom::rsg_type GaussianRandomSequenceGenerator;
typedef QuantLib::LowDiscrepancy::rsg_type
    GaussianLowDiscrepancySequenceGenerator;

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

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

typedef QuantLib::MultiPathGenerator<GaussianRandomSequenceGenerator>
    GaussianMultiPathGenerator;

SWIGINTERN MultiPath Sample_Sl_MultiPath_Sg__value(Sample< MultiPath > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_MultiPath_Sg__weight(Sample< MultiPath > *self){ return self->weight; }
SWIGINTERN GaussianMultiPathGenerator *new_GaussianMultiPathGenerator__SWIG_0(ext::shared_ptr< StochasticProcess > const &process,std::vector< Time,std::allocator< Time > > const &times,GaussianRandomSequenceGenerator const &generator,bool brownianBridge=false){
          return new GaussianMultiPathGenerator(process,
                                                QuantLib::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());
    }

using QuantLib::Disposable;


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 Disposable<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;
using QuantLib::BrownianGeneratorFactory;
using QuantLib::MTBrownianGeneratorFactory;
using QuantLib::SobolBrownianGeneratorFactory;

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



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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      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;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::incr(size_t)\n"
    "    swig::SwigPyIterator::incr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      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;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::decr(size_t)\n"
    "    swig::SwigPyIterator::decr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    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;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


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

SWIGINTERN PyObject *_wrap_new_Period__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Period__SWIG_3(PyObject *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< Period >::__getitem__(std::vector< Period >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< Period,std::allocator< Period > > const &)\n"
    "    std::vector< Period >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const std::vector< Period >::value_type& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_append(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,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_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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_todaysDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_localDateTime(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_universalDateTime(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_endOfMonth(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_isEndOfMonth(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_nthWeekday(PyObject *SWIGUNUSEDPARM(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(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___add____SWIG_0(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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;
    {
      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;
    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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< Date >::__getitem__(std::vector< Date >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< Date,std::allocator< Date > > const &)\n"
    "    std::vector< Date >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const std::vector< Date >::value_type& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_append(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,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_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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
    "    std::vector< int >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< unsigned int >::__getitem__(std::vector< unsigned int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    std::vector< unsigned int >::__setitem__(PySliceObject *)\n"
    "    std::vector< unsigned int >::__setitem__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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(static_cast< const std::vector< unsigned int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< unsigned int >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< unsigned int >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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;
    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;
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::vector< unsigned int >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::size_type arg3 ;
  std::vector< unsigned int >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< unsigned int >::value_type temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
    "    std::vector< double >::__setitem__(PySliceObject *)\n"
    "    std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  std::vector< double >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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;
    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;
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::size_type arg3 ;
  std::vector< double >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< double >::value_type temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StrVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StrVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StrVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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;
    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;
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< bool >::__getitem__(std::vector< bool >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< bool,std::allocator< bool > > const &)\n"
    "    std::vector< bool >::__setitem__(PySliceObject *)\n"
    "    std::vector< bool >::__setitem__(std::vector< bool >::difference_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector_pop(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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_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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_DoublePair__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
    "    std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_NodePair__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NodeVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &)\n"
    "    std::vector< std::pair< Date,double > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Exercise(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_dateAt(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_dates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Exercise(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Observable(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  Array *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    {
      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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_new_Array__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const 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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_Array___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    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 {
          Matrix* m;
          if (SWIG_ConvertPtr(argv[1],(void **) &m,
              SWIGTYPE_p_Matrix,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___setslice__(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[3],&temp4)) {
      arg4 = &temp4;
    } else {
      if (SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_DefaultLexicographicalViewColumn___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalViewColumn *arg1 = (DefaultLexicographicalViewColumn *) 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, "DefaultLexicographicalViewColumn___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultLexicographicalViewColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultLexicographicalViewColumn___getitem__" "', argument " "1"" of type '" "DefaultLexicographicalViewColumn *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalViewColumn * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultLexicographicalViewColumn___getitem__" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)DefaultLexicographicalViewColumn___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_DefaultLexicographicalViewColumn___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalViewColumn *arg1 = (DefaultLexicographicalViewColumn *) 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, "DefaultLexicographicalViewColumn___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultLexicographicalViewColumn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultLexicographicalViewColumn___setitem__" "', argument " "1"" of type '" "DefaultLexicographicalViewColumn *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalViewColumn * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultLexicographicalViewColumn___setitem__" "', 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 '" "DefaultLexicographicalViewColumn___setitem__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      DefaultLexicographicalViewColumn___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_DefaultLexicographicalViewColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalViewColumn *arg1 = (DefaultLexicographicalViewColumn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultLexicographicalViewColumn, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultLexicographicalViewColumn" "', argument " "1"" of type '" "DefaultLexicographicalViewColumn *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalViewColumn * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_LexicographicalView_xSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 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_DefaultLexicographicalView, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicographicalView_xSize" "', argument " "1"" of type '" "DefaultLexicographicalView const *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalView * >(argp1);
  {
    try {
      result = ((DefaultLexicographicalView const *)arg1)->xSize();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_LexicographicalView_ySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 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_DefaultLexicographicalView, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicographicalView_ySize" "', argument " "1"" of type '" "DefaultLexicographicalView const *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalView * >(argp1);
  {
    try {
      result = ((DefaultLexicographicalView const *)arg1)->ySize();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_LexicographicalView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DefaultLexicographicalView *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LexicographicalView", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LexicographicalView" "', argument " "1"" of type '" "Array &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LexicographicalView" "', argument " "1"" of type '" "Array &""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LexicographicalView" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (DefaultLexicographicalView *)new_DefaultLexicographicalView(*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DefaultLexicographicalView, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LexicographicalView___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 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_DefaultLexicographicalView, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicographicalView___str__" "', argument " "1"" of type '" "DefaultLexicographicalView *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalView * >(argp1);
  {
    try {
      result = DefaultLexicographicalView___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_LexicographicalView___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< DefaultLexicographicalViewColumn > result;
  
  if (!SWIG_Python_UnpackTuple(args, "LexicographicalView___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultLexicographicalView, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicographicalView___getitem__" "', argument " "1"" of type '" "DefaultLexicographicalView *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalView * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LexicographicalView___getitem__" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = DefaultLexicographicalView___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 DefaultLexicographicalViewColumn(static_cast< const DefaultLexicographicalViewColumn& >(result))), SWIGTYPE_p_DefaultLexicographicalViewColumn, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LexicographicalView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLexicographicalView *arg1 = (DefaultLexicographicalView *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultLexicographicalView, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LexicographicalView" "', argument " "1"" of type '" "DefaultLexicographicalView *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLexicographicalView * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_MatrixRow___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MatrixRow *arg1 = (MatrixRow *) 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, "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_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixRow___getitem__" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)MatrixRow___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_MatrixRow___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MatrixRow *arg1 = (MatrixRow *) 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, "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_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixRow___setitem__" "', 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 '" "MatrixRow___setitem__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      MatrixRow___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_MatrixRow(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg1 = &temp1;
    } else {
      SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        _v = 1;
        /* wrapped Matrix? */
      } else {
        Matrix* m;
        if (SWIG_ConvertPtr(argv[0],(void **) &m,
            SWIGTYPE_p_Matrix,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    if (_v) {
      return _wrap_new_Matrix__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const 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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const 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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_Matrix___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    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 {
          Matrix* m;
          if (SWIG_ConvertPtr(argv[1],(void **) &m,
              SWIGTYPE_p_Matrix,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix___getitem__" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(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(static_cast< const MatrixRow& >(result))), SWIGTYPE_p_MatrixRow, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Matrix___rmul____SWIG_0(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const 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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const 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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_Matrix___rmul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    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 {
          Matrix* m;
          if (SWIG_ConvertPtr(argv[1],(void **) &m,
              SWIGTYPE_p_Matrix,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg1 = &temp1;
    } else {
      SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg1 = &temp1;
    } else {
      SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_outerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "outerProduct", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pseudoSqrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  SalvagingAlgorithm::Type arg2 ;
  Matrix temp1 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg1 = &temp1;
    } else {
      SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Matrix,1);
    }
  }
  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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SVD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg1 = &temp1;
    } else {
      SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SVD_singularValues(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = (MatrixMultiplicationProxy *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MatrixMultiplicationProxy(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Array temp3 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BiCGstab_solve__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const 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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_BiCGstab_solve__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Array temp3 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GMRES_solve__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const 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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_GMRES_solve__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        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 *SWIGUNUSEDPARM(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 ;
  Array temp4 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[3],&temp4)) {
      arg4 = &temp4;
    } else {
      if (SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    try {
      result = GMRES_solveWithRestart__SWIG_0((GMRES const *)arg1,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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GMRES_solveWithRestart__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    try {
      result = GMRES_solveWithRestart__SWIG_0((GMRES 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");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(static_cast< const 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;
    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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        if (_v) {
          return _wrap_GMRES_solveWithRestart__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        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 {
              /* wrapped Array? */
              Array* v;
              if (SWIG_ConvertPtr(argv[3],(void **) &v,
                  SWIGTYPE_p_Array,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_DerivedQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)\n"
    "    std::vector< ext::shared_ptr< Quote > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< Handle< Quote > >::__getitem__(std::vector< Handle< Quote > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    std::vector< Handle< Quote > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< RelinkableHandle< Quote > >::__getitem__(std::vector< RelinkableHandle< Quote > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)\n"
    "    std::vector< RelinkableHandle< Quote > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Calendar_isWeekend(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_isBusinessDay(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_adjust__SWIG_0(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_adjust__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_4(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_5(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Argentina__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Australia *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Australia", 0, 0, 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_delete_Australia(PyObject *SWIGUNUSEDPARM(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_Brazil__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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_China__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Russia__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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_Romania(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Romania *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Romania", 0, 0, 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_delete_Romania(PyObject *SWIGUNUSEDPARM(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_SaudiArabia__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::UnitedStates::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::UnitedStates *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_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_new_UnitedStates__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::UnitedStates *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::UnitedStates *)new QuantLib::UnitedStates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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_new_UnitedStates(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnitedStates", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UnitedStates__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UnitedStates__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnitedStates'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::UnitedStates::UnitedStates(QuantLib::UnitedStates::Market)\n"
    "    QuantLib::UnitedStates::UnitedStates()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnitedStates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(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 == 2) {
    int _v;
    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 == 3) {
    int _v;
    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;
    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;
    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;
    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;
    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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_JointCalendar(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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_Actual364(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Thirty360 *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Thirty360 *)new QuantLib::Thirty360();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Thirty360", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Thirty360__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _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)\n"
    "    QuantLib::Thirty360::Thirty360()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Thirty360(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::ActualActual *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ActualActual *)new QuantLib::ActualActual();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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 == 0) {
    return _wrap_new_ActualActual__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      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;
    {
      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"
    "    QuantLib::ActualActual::ActualActual()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ActualActual(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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_new_InterestRate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_compounding(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< InterestRate >::__getitem__(std::vector< InterestRate >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< InterestRate,std::allocator< InterestRate > > const &)\n"
    "    std::vector< InterestRate >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const std::vector< InterestRate >::value_type& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_append(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Rounding(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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_Currency_name(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Currency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Currency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Currency", 0, 0, 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_delete_Currency(PyObject *SWIGUNUSEDPARM(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_ARSCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BGLCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BRLCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BYRCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CLPCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CNYCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CYPCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_ESPCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_EURCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GBPCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GRDCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_HUFCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_IEPCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_IDRCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_ILSCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_JPYCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_KRWCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_LTLCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_MTLCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_MXNCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_MYRCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_NLGCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_PEHCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_PKRCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_ROLCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_RUBCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_TRLCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_USDCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_VEBCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_ZARCurrency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Brent_setMaxEvaluations(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  NonhomogeneousBoundaryConstraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NonhomogeneousBoundaryConstraint", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  unsigned long arg3 ;
  Array temp1 ;
  Array temp2 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  SamplerMirrorGaussian *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  SamplerMirrorGaussian *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_new_SamplerMirrorGaussian__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Optimizer(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeLinearInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LinearInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeLogLinearInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogLinearInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeBackwardFlatInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BackwardFlatInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeForwardFlatInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ForwardFlatInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeLogCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogCubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicCubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicLogCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicLogCubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeKrugerCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KrugerCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeKrugerLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KrugerLogCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeFritschButlandCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FritschButlandCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeFritschButlandLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FritschButlandLogCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Parabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeLogParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogParabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicParabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicLogParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicLogParabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_BilinearInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  Array temp1 ;
  Array temp2 ;
  Matrix temp3 ;
  PyObject *swig_obj[3] ;
  SafeBilinearInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BilinearInterpolation", 3, 3, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg3 = &temp3;
    } else {
      SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  Array temp1 ;
  Array temp2 ;
  Matrix temp3 ;
  PyObject *swig_obj[3] ;
  SafeBicubicSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BicubicSpline", 3, 3, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg3 = &temp3;
    } else {
      SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_new_BackwardFlat(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Kruger(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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_SABRInterpolation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  bool arg17 ;
  Size arg18 ;
  Real arg19 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &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;
    }
  }
  {
    int newmem = 0;
    res15 = SWIG_ConvertPtrAndOwn(swig_obj[14], &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;
    }
  }
  ecode16 = SWIG_AsVal_double(swig_obj[15], &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);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &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);
  ecode18 = SWIG_AsVal_size_t(swig_obj[17], &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);
  ecode19 = SWIG_AsVal_double(swig_obj[18], &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_new_SABRInterpolation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  bool arg17 ;
  Size arg18 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &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;
    }
  }
  {
    int newmem = 0;
    res15 = SWIG_ConvertPtrAndOwn(swig_obj[14], &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;
    }
  }
  ecode16 = SWIG_AsVal_double(swig_obj[15], &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);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &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);
  ecode18 = SWIG_AsVal_size_t(swig_obj[17], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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_new_SABRInterpolation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  bool arg17 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &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;
    }
  }
  {
    int newmem = 0;
    res15 = SWIG_ConvertPtrAndOwn(swig_obj[14], &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;
    }
  }
  ecode16 = SWIG_AsVal_double(swig_obj[15], &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);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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_new_SABRInterpolation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &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;
    }
  }
  {
    int newmem = 0;
    res15 = SWIG_ConvertPtrAndOwn(swig_obj[14], &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;
    }
  }
  ecode16 = SWIG_AsVal_double(swig_obj[15], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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_new_SABRInterpolation__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &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;
    }
  }
  {
    int newmem = 0;
    res15 = SWIG_ConvertPtrAndOwn(swig_obj[14], &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;
    }
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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_new_SABRInterpolation__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &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;
    }
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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_new_SABRInterpolation__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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);
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeSABRInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SABRInterpolation__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  Array temp1 ;
  Array temp2 ;
  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 ;
  SafeSABRInterpolation *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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(swig_obj[5], &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(swig_obj[6], &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(swig_obj[7], &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);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &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);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &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);
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array 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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeSABRInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SABRInterpolation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[20] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SABRInterpolation", 0, 19, argv))) SWIG_fail;
  --argc;
  if (argc == 12) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_SABRInterpolation__SWIG_7(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_SABRInterpolation__SWIG_6(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_SABRInterpolation__SWIG_5(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_SABRInterpolation__SWIG_4(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SABRInterpolation__SWIG_3(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(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_SABRInterpolation__SWIG_2(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(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_AsVal_size_t(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_new_SABRInterpolation__SWIG_1(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
                {
                  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_bool(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_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_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(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_AsVal_size_t(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_SABRInterpolation__SWIG_0(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SABRInterpolation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const,Size const,Real const)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const,Size const)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Real const)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    SafeSABRInterpolation::SafeSABRInterpolation(Array const &,Array const &,Time,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation___call____SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    _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;
    _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 *SWIGUNUSEDPARM(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_ConvexMonotoneInterpolation__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  Array temp2 ;
  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 (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Array temp1 ;
  Array temp2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Array temp1 ;
  Array temp2 ;
  double val3 ;
  int ecode3 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  Array temp2 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_new_ConvexMonotoneInterpolation__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
            return _wrap_new_ConvexMonotoneInterpolation__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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_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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_4(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_5(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_4(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_5(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_4(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_5(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_3(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_4(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_5(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_SpreadedLinearZeroInterpolatedTermStructure__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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_SpreadedLinearZeroInterpolatedTermStructure__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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_SpreadedLinearZeroInterpolatedTermStructure__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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_SpreadedLinearZeroInterpolatedTermStructure__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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_SpreadedLinearZeroInterpolatedTermStructure__SWIG_4(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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_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;
    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;
    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;
    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;
    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;
    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"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >::InterpolatedPiecewiseZeroSpreadedTermStructure(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"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >::InterpolatedPiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &)\n"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >::InterpolatedPiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency)\n"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >::InterpolatedPiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding)\n"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< Linear >::InterpolatedPiecewiseZeroSpreadedTermStructure(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *arg1 = (InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedPiecewiseZeroSpreadedTermStructure< 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_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedPiecewiseZeroSpreadedTermStructure< 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 *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_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_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 *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_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_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_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_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_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_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_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_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_4(PyObject *SWIGUNUSEDPARM(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 ;
  InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *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 = (InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *)new InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >((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<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_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_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;
    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;
    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;
    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;
    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;
    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"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >::InterpolatedPiecewiseZeroSpreadedTermStructure(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"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >::InterpolatedPiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &)\n"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >::InterpolatedPiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency)\n"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >::InterpolatedPiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding)\n"
    "    InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat >::InterpolatedPiecewiseZeroSpreadedTermStructure(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *arg1 = (InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > > tempshared1 ;
  ext::shared_ptr< InterpolatedPiecewiseZeroSpreadedTermStructure< 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_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedPiecewiseZeroSpreadedTermStructure< 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 *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_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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_RealTimeSeries__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 > >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const IntervalPrice& >(result))), SWIGTYPE_p_IntervalPrice, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceTimeSeries___setitem__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\n"
    "    std::vector< IntervalPrice >::__getitem__(std::vector< IntervalPrice >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)\n"
    "    std::vector< IntervalPrice >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const std::vector< IntervalPrice >::value_type& >(result))), SWIGTYPE_p_IntervalPrice, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_append(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& 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 *SWIGUNUSEDPARM(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(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_IndexManager(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_isValidFixingDate(PyObject *SWIGUNUSEDPARM(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_fixing__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_fixingDays(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_currency(PyObject *SWIGUNUSEDPARM(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(static_cast< const Currency& >(result))), SWIGTYPE_p_Currency, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_dayCounter(PyObject *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_valueDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InterestRateIndex(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborIndex_clone(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndex *arg1 = (OvernightIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared1 ;
  ext::shared_ptr< OvernightIndex > *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 *""'");
    }
    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));
    }
  }
  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(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_fixedLegConvention(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_discountingTermStructure(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_AUDLibor__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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_Eonia__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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_Sonia__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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_FedFunds__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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_EuriborSwapIsdaFixA__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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_VolatilityTermStructure_minStrike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_frequency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_timeFromBase__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_frequency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_RelinkableYoYOptionletVolatilitySurface__SWIG_0(PyObject *SWIGUNUSEDPARM(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_RelinkableYoYOptionletVolatilitySurface" "', 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_RelinkableYoYOptionletVolatilitySurface__SWIG_1(PyObject *SWIGUNUSEDPARM(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_RelinkableYoYOptionletVolatilitySurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableYoYOptionletVolatilitySurface", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableYoYOptionletVolatilitySurface__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableYoYOptionletVolatilitySurface__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableYoYOptionletVolatilitySurface'.\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_RelinkableYoYOptionletVolatilitySurface_linkTo(PyObject *SWIGUNUSEDPARM(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, "RelinkableYoYOptionletVolatilitySurface_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 '" "RelinkableYoYOptionletVolatilitySurface_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 '" "RelinkableYoYOptionletVolatilitySurface_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_RelinkableYoYOptionletVolatilitySurface_reset(PyObject *SWIGUNUSEDPARM(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 '" "RelinkableYoYOptionletVolatilitySurface_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_RelinkableYoYOptionletVolatilitySurface(PyObject *SWIGUNUSEDPARM(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_RelinkableYoYOptionletVolatilitySurface" "', 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 *RelinkableYoYOptionletVolatilitySurface_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 *RelinkableYoYOptionletVolatilitySurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SmileSection_minStrike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg5 = &temp5;
    } else {
      SWIG_ConvertPtr(obj4,(void **) &arg5,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_LocalConstantVol__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_ConstantOptionletVolatility__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolatilityDiscrete(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Matrix temp10 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg10 = &temp10;
    } else {
      SWIG_ConvertPtr(swig_obj[9],(void **) &arg10,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  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;
  }
  {
    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);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, 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(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 (!argp9) {
    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 = reinterpret_cast< std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > * >(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,(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;
  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_5(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Matrix temp9 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg5 = &temp5;
    } else {
      SWIG_ConvertPtr(swig_obj[4],(void **) &arg5,SWIGTYPE_p_Matrix,1);
    }
  }
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg9 = &temp9;
    } else {
      SWIG_ConvertPtr(swig_obj[8],(void **) &arg9,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg5 = &temp5;
    } else {
      SWIG_ConvertPtr(swig_obj[4],(void **) &arg5,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg5 = &temp5;
    } else {
      SWIG_ConvertPtr(swig_obj[4],(void **) &arg5,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg5 = &temp5;
    } else {
      SWIG_ConvertPtr(swig_obj[4],(void **) &arg5,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Matrix temp8 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg8 = &temp8;
    } else {
      SWIG_ConvertPtr(swig_obj[7],(void **) &arg8,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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;
    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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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;
    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 {
                Matrix* m;
                if (SWIG_ConvertPtr(argv[4],(void **) &m,
                    SWIGTYPE_p_Matrix,0) != -1)
                _v = 1;
                else
                _v = 0;
              }
            }
            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;
    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;
    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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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;
    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 {
                Matrix* m;
                if (SWIG_ConvertPtr(argv[4],(void **) &m,
                    SWIGTYPE_p_Matrix,0) != -1)
                _v = 1;
                else
                _v = 0;
              }
            }
            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;
    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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              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;
    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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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 {
                      Matrix* m;
                      if (SWIG_ConvertPtr(argv[7],(void **) &m,
                          SWIGTYPE_p_Matrix,0) != -1)
                      _v = 1;
                      else
                      _v = 0;
                    }
                  }
                  if (_v) {
                    return _wrap_new_SwaptionVolatilityMatrix__SWIG_12(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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 {
                Matrix* m;
                if (SWIG_ConvertPtr(argv[4],(void **) &m,
                    SWIGTYPE_p_Matrix,0) != -1)
                _v = 1;
                else
                _v = 0;
              }
            }
            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;
    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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              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;
    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_ConvertPtr(argv[8], 0, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_SwaptionVolatilityMatrix__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    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 {
                Matrix* m;
                if (SWIG_ConvertPtr(argv[4],(void **) &m,
                    SWIGTYPE_p_Matrix,0) != -1)
                _v = 1;
                else
                _v = 0;
              }
            }
            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 {
                        Matrix* m;
                        if (SWIG_ConvertPtr(argv[8],(void **) &m,
                            SWIGTYPE_p_Matrix,0) != -1)
                        _v = 1;
                        else
                        _v = 0;
                      }
                    }
                    if (_v) {
                      return _wrap_new_SwaptionVolatilityMatrix__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              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 {
                          Matrix* m;
                          if (SWIG_ConvertPtr(argv[9],(void **) &m,
                              SWIGTYPE_p_Matrix,0) != -1)
                          _v = 1;
                          else
                          _v = 0;
                        }
                      }
                      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 *SWIGUNUSEDPARM(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 ;
  SwigValueWrapper< std::pair< size_t,size_t > > 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 const *)arg1)->locate((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 std::pair< Size,Size >(static_cast< const std::pair< Size,Size >& >(result))), SWIGTYPE_p_std__pairT_size_t_size_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityMatrix_locate__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  SwigValueWrapper< std::pair< size_t,size_t > > 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 const *)arg1)->locate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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< Size,Size >(static_cast< const std::pair< Size,Size >& >(result))), SWIGTYPE_p_std__pairT_size_t_size_t_t, SWIG_POINTER_OWN |  0 );
  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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', 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_SabrSmileSection" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((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<  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 *SWIGUNUSEDPARM(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 ;
  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_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((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<  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 *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SabrSmileSection", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      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_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_SabrSmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_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 &,DayCounter const &,Real)\n"
    "    SabrSmileSection::SabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter 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)\n"
    "    SabrSmileSection::SabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SabrSmileSection_alpha(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_SwaptionVolatilityCube_atmStrike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_SwaptionVolCube1__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "19"" of type '" "Real""'");
  } 
  arg19 = static_cast< Real >(val19);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "17"" of type '" "Size""'");
  } 
  arg17 = static_cast< Size >(val17);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_4(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_5(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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 = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_6(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_7(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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 = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1__SWIG_8(PyObject *SWIGUNUSEDPARM(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 ;
  SwaptionVolCube1 *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_SwaptionVolCube1" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube1" "', 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_SwaptionVolCube1" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (SwaptionVolCube1 *)new SwaptionVolCube1((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<  SwaptionVolCube1 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[20] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwaptionVolCube1", 0, 19, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v;
    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_SwaptionVolCube1__SWIG_8(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    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_SwaptionVolCube1__SWIG_7(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    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_SwaptionVolCube1__SWIG_6(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    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_SwaptionVolCube1__SWIG_5(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    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_SwaptionVolCube1__SWIG_4(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    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_SwaptionVolCube1__SWIG_3(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    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_SwaptionVolCube1__SWIG_2(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    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_SwaptionVolCube1__SWIG_1(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    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_SwaptionVolCube1__SWIG_0(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwaptionVolCube1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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"
    "    SwaptionVolCube1::SwaptionVolCube1(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_SwaptionVolCube1_sparseSabrParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 const > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_sparseSabrParameters" "', argument " "1"" of type '" "SwaptionVolCube1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwaptionVolCube1 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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolCube1_denseSabrParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 const > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_denseSabrParameters" "', argument " "1"" of type '" "SwaptionVolCube1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwaptionVolCube1 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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolCube1_marketVolCube(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 const > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_marketVolCube" "', argument " "1"" of type '" "SwaptionVolCube1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwaptionVolCube1 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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolCube1_volCubeAtmCalibrated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 const > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_volCubeAtmCalibrated" "', argument " "1"" of type '" "SwaptionVolCube1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwaptionVolCube1 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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolCube1_smileSection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 > *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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_smileSection" "', argument " "1"" of type '" "SwaptionVolCube1 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolCube1_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 '" "SwaptionVolCube1_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 '" "SwaptionVolCube1_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = SwaptionVolCube1_smileSection__SWIG_0(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_SwaptionVolCube1_smileSection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 > *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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_smileSection" "', argument " "1"" of type '" "SwaptionVolCube1 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolCube1_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 '" "SwaptionVolCube1_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = SwaptionVolCube1_smileSection__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");
    }
  }
  {
    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_SwaptionVolCube1_smileSection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 > *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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_smileSection" "', argument " "1"" of type '" "SwaptionVolCube1 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((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 '" "SwaptionVolCube1_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolCube1_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 '" "SwaptionVolCube1_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolCube1_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 '" "SwaptionVolCube1_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = SwaptionVolCube1_smileSection__SWIG_2(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_SwaptionVolCube1_smileSection__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 > *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_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolCube1_smileSection" "', argument " "1"" of type '" "SwaptionVolCube1 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((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 '" "SwaptionVolCube1_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolCube1_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 '" "SwaptionVolCube1_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolCube1_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = SwaptionVolCube1_smileSection__SWIG_2(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_SwaptionVolCube1_smileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolCube1_smileSection", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1_smileSection__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1_smileSection__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1_smileSection__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_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_SwaptionVolCube1_smileSection__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolCube1_smileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolCube1::smileSection(Time,Time,bool)\n"
    "    SwaptionVolCube1::smileSection(Time,Time)\n"
    "    SwaptionVolCube1::smileSection(Period const &,Period const &,bool)\n"
    "    SwaptionVolCube1::smileSection(Period const &,Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolCube1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolCube1 *arg1 = (SwaptionVolCube1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube1 > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube1 > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolCube1" "', argument " "1"" of type '" "SwaptionVolCube1 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolCube1 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SwaptionVolCube2(PyObject *SWIGUNUSEDPARM(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] ;
  SwaptionVolCube2 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SwaptionVolCube2", 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_SwaptionVolCube2" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', 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_SwaptionVolCube2" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (SwaptionVolCube2 *)new SwaptionVolCube2((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<  SwaptionVolCube2 > *smartresult = result ? new ext::shared_ptr<  SwaptionVolCube2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube2_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_SwaptionVolCube2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolCube2 *arg1 = (SwaptionVolCube2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolCube2 > tempshared1 ;
  ext::shared_ptr< SwaptionVolCube2 > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolCube2_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolCube2" "', argument " "1"" of type '" "SwaptionVolCube2 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolCube2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolCube2 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube2 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolCube2 > * >(argp1);
      arg1 = const_cast< SwaptionVolCube2 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ConstantYoYOptionletVolatility__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoArbSabrSmileSection", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      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_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_2(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)\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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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, "sabrVolatility", 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 '" "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_shiftedSabrVolatility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject *swig_obj[8] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "shiftedSabrVolatility", 8, 8, swig_obj)) 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_sabrFlochKennedyVolatility(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_minStrike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedSpreadError(PyObject *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Disposable< 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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 Disposable< Array >(static_cast< const Disposable< Array >& >(result))), SWIGTYPE_p_DisposableT_Array_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedSpotNpvErrors(PyObject *SWIGUNUSEDPARM(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 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Disposable< 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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 Disposable< Array >(static_cast< const Disposable< Array >& >(result))), SWIGTYPE_p_DisposableT_Array_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedFwdNpvErrors(PyObject *SWIGUNUSEDPARM(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 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Disposable< 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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 Disposable< Array >(static_cast< const Disposable< Array >& >(result))), SWIGTYPE_p_DisposableT_Array_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsMarket(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg3 = &temp3;
    } else {
      SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[3],&temp4)) {
      arg4 = &temp4;
    } else {
      if (SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_compute__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_compute__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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(static_cast< const 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;
    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 {
              /* wrapped Array? */
              Array* v;
              if (SWIG_ConvertPtr(argv[3],(void **) &v,
                  SWIGTYPE_p_Array,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_computeParametric__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg4 = &temp4;
    } else {
      SWIG_ConvertPtr(swig_obj[3],(void **) &arg4,SWIGTYPE_p_Matrix,1);
    }
  }
  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(static_cast< const 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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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;
    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 {
              Matrix* m;
              if (SWIG_ConvertPtr(argv[3],(void **) &m,
                  SWIGTYPE_p_Matrix,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_StochasticProcess_size(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_drift(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_diffusion(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_expectation(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_stdDeviation(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_covariance(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_evolve(PyObject *SWIGUNUSEDPARM(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 ;
  double val4 ;
  int ecode4 = 0 ;
  Array temp5 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 (extractArray(swig_obj[4],&temp5)) {
      arg5 = &temp5;
    } else {
      if (SWIG_ConvertPtr(swig_obj[4],(void **) &arg5,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StochasticProcess(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_dividendYield(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_riskFreeRate(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_blackVolatility(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< BlackVolTermStructure >& >(result))), SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GeneralizedBlackScholesProcess(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonProcess_dividendYield(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonProcess_riskFreeRate(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonProcess(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Array temp1 ;
  Array temp2 ;
  Array temp3 ;
  double val4 ;
  int ecode4 = 0 ;
  GsrProcess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Array temp1 ;
  Array temp2 ;
  Array temp3 ;
  GsrProcess *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        if (_v) {
          return _wrap_new_GsrProcess__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHProcess_dividendYield(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHProcess_riskFreeRate(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GJRGARCHProcess(PyObject *SWIGUNUSEDPARM(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_delete_PricingEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Instrument_recalculate(PyObject *SWIGUNUSEDPARM(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 '" "Instrument_recalculate" "', 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 {
      (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_Instrument_freeze(PyObject *SWIGUNUSEDPARM(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 '" "Instrument_freeze" "', 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 {
      (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_Instrument_unfreeze(PyObject *SWIGUNUSEDPARM(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 '" "Instrument_unfreeze" "', 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 {
      (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_Instrument(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_new_DateGeneration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  boost::optional< BusinessDayConvention > arg4 ;
  boost::optional< Period > arg5 ;
  boost::optional< DateGeneration::Rule > arg6 ;
  boost::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 = boost::none;
  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 = boost::none;
  else
  {
    Period *temp;
    if (!SWIG_IsOK(SWIG_ConvertPtr(swig_obj[4],(void **) &temp, SWIGTYPE_p_Period,0)))
    SWIG_exception_fail(SWIG_TypeError, "in method 'new_Schedule', expecting type Period");
    arg5 = (boost::optional<Period>) *temp;
  }
  
  
  if(swig_obj[5] == Py_None)
  arg6 = boost::none;
  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 = boost::none;
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  boost::optional< BusinessDayConvention > arg4 ;
  boost::optional< Period > arg5 ;
  boost::optional< DateGeneration::Rule > arg6 ;
  boost::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 = boost::none;
  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 = boost::none;
  else
  {
    Period *temp;
    if (!SWIG_IsOK(SWIG_ConvertPtr(swig_obj[4],(void **) &temp, SWIGTYPE_p_Period,0)))
    SWIG_exception_fail(SWIG_TypeError, "in method 'new_Schedule', expecting type Period");
    arg5 = (boost::optional<Period>) *temp;
  }
  
  
  if(swig_obj[5] == Py_None)
  arg6 = boost::none;
  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 = boost::none;
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  boost::optional< BusinessDayConvention > arg4 ;
  boost::optional< Period > arg5 ;
  boost::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 = boost::none;
  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 = boost::none;
  else
  {
    Period *temp;
    if (!SWIG_IsOK(SWIG_ConvertPtr(swig_obj[4],(void **) &temp, SWIGTYPE_p_Period,0)))
    SWIG_exception_fail(SWIG_TypeError, "in method 'new_Schedule', expecting type Period");
    arg5 = (boost::optional<Period>) *temp;
  }
  
  
  if(swig_obj[5] == Py_None)
  arg6 = boost::none;
  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  boost::optional< BusinessDayConvention > arg4 ;
  boost::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 = boost::none;
  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 = boost::none;
  else
  {
    Period *temp;
    if (!SWIG_IsOK(SWIG_ConvertPtr(swig_obj[4],(void **) &temp, SWIGTYPE_p_Period,0)))
    SWIG_exception_fail(SWIG_TypeError, "in method 'new_Schedule', expecting type Period");
    arg5 = (boost::optional<Period>) *temp;
  }
  
  {
    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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  boost::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 = boost::none;
  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 {
                Period *temp;
                int res = SWIG_ConvertPtr(argv[4],(void **) &temp, SWIGTYPE_p_Period,0);
                _v = SWIG_IsOK(res) ? 1 : 0;
              }
              
            }
            if (_v) {
              return _wrap_new_Schedule__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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 {
                Period *temp;
                int res = SWIG_ConvertPtr(argv[4],(void **) &temp, SWIGTYPE_p_Period,0);
                _v = SWIG_IsOK(res) ? 1 : 0;
              }
              
            }
            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;
    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 {
                Period *temp;
                int res = SWIG_ConvertPtr(argv[4],(void **) &temp, SWIGTYPE_p_Period,0);
                _v = SWIG_IsOK(res) ? 1 : 0;
              }
              
            }
            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;
    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;
    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 {
                Period *temp;
                int res = SWIG_ConvertPtr(argv[4],(void **) &temp, SWIGTYPE_p_Period,0);
                _v = SWIG_IsOK(res) ? 1 : 0;
              }
              
            }
            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;
    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;
    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,boost::optional< BusinessDayConvention >,boost::optional< Period > const,boost::optional< DateGeneration::Rule >,boost::optional< bool >,std::vector< bool,std::allocator< bool > > const &)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,boost::optional< BusinessDayConvention >,boost::optional< Period > const,boost::optional< DateGeneration::Rule >,boost::optional< bool >)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,boost::optional< BusinessDayConvention >,boost::optional< Period > const,boost::optional< DateGeneration::Rule >)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,boost::optional< BusinessDayConvention >,boost::optional< Period > const)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,boost::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_nextDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_hasIsRegular(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_until(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Schedule_until" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((Schedule const *)arg1)->until(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const Schedule& >(result))), SWIGTYPE_p_Schedule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule___getitem__(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Schedule(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Schedule& >(result))), SWIGTYPE_p_Schedule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__MakeSchedule(PyObject *SWIGUNUSEDPARM(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_CashFlow_amount(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlow_hasOccurred__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_SimpleCashFlow(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_fixingDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_index(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accrualEndDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_referencePeriodStart(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_referencePeriodEnd(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_exCouponDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_rate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accruedAmount(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedRateCoupon(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "setCouponPricer", 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 '" "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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_fixingDays(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_OvernightIndexedCoupon__SWIG_0(PyObject *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexedCoupon", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v;
    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_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    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_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    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_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    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_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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_CappedFlooredCoupon(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_IborCouponPricer_capletVolatility(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricer::TimingAdjustment arg2 ;
  Handle< Quote > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  BlackIborCouponPricer *result = 0 ;
  
  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 '" "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);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &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);
  {
    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_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;
    }
  }
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< OptionletVolatilityStructure > 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<  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_new_BlackIborCouponPricer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricer::TimingAdjustment arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  BlackIborCouponPricer *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) 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 '" "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);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &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);
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< OptionletVolatilityStructure > 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<  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_new_BlackIborCouponPricer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BlackIborCouponPricer *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) 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 '" "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);
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< 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");
    }
  }
  {
    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_new_BlackIborCouponPricer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BlackIborCouponPricer *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_BlackIborCouponPricer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackIborCouponPricer", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BlackIborCouponPricer__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BlackIborCouponPricer__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_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_BlackIborCouponPricer__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_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_BlackIborCouponPricer__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackIborCouponPricer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackIborCouponPricer::BlackIborCouponPricer(Handle< OptionletVolatilityStructure > const &,BlackIborCouponPricer::TimingAdjustment const,Handle< Quote > const)\n"
    "    BlackIborCouponPricer::BlackIborCouponPricer(Handle< OptionletVolatilityStructure > const &,BlackIborCouponPricer::TimingAdjustment const)\n"
    "    BlackIborCouponPricer::BlackIborCouponPricer(Handle< OptionletVolatilityStructure > const &)\n"
    "    BlackIborCouponPricer::BlackIborCouponPricer()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackIborCouponPricer(PyObject *SWIGUNUSEDPARM(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_new_CmsCoupon(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  boost::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 = boost::none;
  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 *SWIGUNUSEDPARM(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 ;
  boost::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 = boost::none;
  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 *SWIGUNUSEDPARM(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 ;
  boost::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 = boost::none;
  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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,boost::optional< VolatilityType > const,Real const,Real const)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Size const,boost::optional< VolatilityType > const,Real const)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Size const,boost::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_FixedRateLeg(PyObject *SWIGUNUSEDPARM(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 ;
  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 ;
  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 *)"schedule",  (char *)"dayCount",  (char *)"nominals",  (char *)"couponRates",  (char *)"paymentAdjustment",  (char *)"firstPeriodDayCount",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOO:FixedRateLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) 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);
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& 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 *SWIGUNUSEDPARM(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 ;
  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 ;
  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:IborLeg", 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 '" "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);
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& 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 *SWIGUNUSEDPARM(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 ;
  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 ;
  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 *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"gearings",  (char *)"spreads",  (char *)"telescopicValueDates",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOO:OvernightLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) 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);
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Duration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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_previousCashFlow__SWIG_0(PyObject *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_7(PyObject *SWIGUNUSEDPARM(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,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_10(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_7(PyObject *SWIGUNUSEDPARM(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,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_10(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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_atmRate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,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");
    }
  }
  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 *SWIGUNUSEDPARM(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,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));
  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 *SWIGUNUSEDPARM(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,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));
  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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_4(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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_duration__SWIG_3(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_1(PyObject *SWIGUNUSEDPARM(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,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_4(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_1(PyObject *SWIGUNUSEDPARM(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,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_4(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,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");
    }
  }
  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 *SWIGUNUSEDPARM(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,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");
    }
  }
  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 *SWIGUNUSEDPARM(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,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));
  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 *SWIGUNUSEDPARM(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,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_zSpread__SWIG_4(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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_CalibrationHelper_calibrationError(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BlackCalibrationHelper_setPricingEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_volatilityType(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj((new ext::shared_ptr< VanillaSwap >(static_cast< const ext::shared_ptr< VanillaSwap >& >(result))), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaption(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaptionStrike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionHelper(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_CalibrationHelperVector_iterator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BlackCalibrationHelperVector_iterator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CalibratedModel_params(PyObject *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_calibrate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_calibrate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_TimeGrid__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Parameter(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_Barrier(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_DoubleBarrier(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_TypePayoff_optionType(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_StrikedTypePayoff_strike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_OneAssetOption_delta(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VanillaOption_impliedVolatility", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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);
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_VanillaOption_priceCurve(PyObject *SWIGUNUSEDPARM(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(static_cast< const SampledCurve& >(result))), SWIGTYPE_p_SampledCurve, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VanillaOption(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  AnalyticEuropeanEngine *result = 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_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_delete_AnalyticEuropeanEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_calibrate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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_chF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine const > tempshared1 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  std::pair< Real,Real > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_chF", 4, 4, 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_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_chF" "', 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_chF" "', 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_chF" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = AnalyticHestonEngine_chF((AnalyticHestonEngine 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(static_cast< std::pair< double,double > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHestonEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussLobatto", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    {
      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_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      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_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)\n"
    "    AnalyticHestonEngine::Integration::gaussLobatto(Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_0(PyObject *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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_andersenPiterbargIntegrationLimit(PyObject *SWIGUNUSEDPARM(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_calculate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  Real arg2 ;
  ext::function< Real (Real) > *arg3 = 0 ;
  doubleOrNull arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  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_calculate" "', argument " "1"" of type '" "AnalyticHestonEngine::Integration const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_ext__functionT_double_fdoubleF_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "3"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "3"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  arg3 = reinterpret_cast< ext::function< Real (Real) > * >(argp3);
  {
    if (swig_obj[3] == Py_None)
    arg4 = Null<double>();
    else if (PyFloat_Check(swig_obj[3]))
    arg4 = PyFloat_AsDouble(swig_obj[3]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (Real)((AnalyticHestonEngine::Integration const *)arg1)->calculate(arg2,(ext::function< Real (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");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_calculate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  Real arg2 ;
  ext::function< Real (Real) > *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_AnalyticHestonEngine__Integration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "1"" of type '" "AnalyticHestonEngine::Integration const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_ext__functionT_double_fdoubleF_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "3"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnalyticHestonEngine_Integration_calculate" "', argument " "3"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  arg3 = reinterpret_cast< ext::function< Real (Real) > * >(argp3);
  {
    try {
      result = (Real)((AnalyticHestonEngine::Integration const *)arg1)->calculate(arg2,(ext::function< Real (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_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_calculate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_calculate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AnalyticHestonEngine__Integration, 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__functionT_double_fdoubleF_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_AnalyticHestonEngine_Integration_calculate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AnalyticHestonEngine__Integration, 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__functionT_double_fdoubleF_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            _v = (argv[3] == Py_None || PyFloat_Check(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_AnalyticHestonEngine_Integration_calculate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_calculate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::calculate(Real,ext::function< Real (Real) > const &,doubleOrNull) const\n"
    "    AnalyticHestonEngine::Integration::calculate(Real,ext::function< Real (Real) > const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_numberOfEvaluations(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_COSHestonEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExponentialFittingHestonEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_FDBermudanEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FDBermudanEngine< CrankNicolson > *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_FDBermudanEngine" "', 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_FDBermudanEngine" "', 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_FDBermudanEngine" "', 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 '" "new_FDBermudanEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FDBermudanEngine< CrankNicolson > *)new FDBermudanEngine< CrankNicolson >((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<  FDBermudanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDBermudanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDBermudanEngine__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  FDBermudanEngine< CrankNicolson > *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_FDBermudanEngine" "', 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_FDBermudanEngine" "', 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_FDBermudanEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FDBermudanEngine< CrankNicolson > *)new FDBermudanEngine< CrankNicolson >((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<  FDBermudanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDBermudanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDBermudanEngine__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  FDBermudanEngine< CrankNicolson > *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_FDBermudanEngine" "', 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_FDBermudanEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FDBermudanEngine< CrankNicolson > *)new FDBermudanEngine< CrankNicolson >((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<  FDBermudanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDBermudanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDBermudanEngine__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  FDBermudanEngine< CrankNicolson > *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_FDBermudanEngine" "', 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 = (FDBermudanEngine< CrankNicolson > *)new FDBermudanEngine< CrankNicolson >((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<  FDBermudanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDBermudanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDBermudanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FDBermudanEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FDBermudanEngine__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_FDBermudanEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_FDBermudanEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FDBermudanEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FDBermudanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FDBermudanEngine< CrankNicolson >::FDBermudanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,bool)\n"
    "    FDBermudanEngine< CrankNicolson >::FDBermudanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FDBermudanEngine< CrankNicolson >::FDBermudanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FDBermudanEngine< CrankNicolson >::FDBermudanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FDBermudanEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FDBermudanEngine< CrankNicolson > *arg1 = (FDBermudanEngine< CrankNicolson > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FDBermudanEngine< CrankNicolson > > tempshared1 ;
  ext::shared_ptr< FDBermudanEngine< CrankNicolson > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FDBermudanEngine" "', argument " "1"" of type '" "FDBermudanEngine< CrankNicolson > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FDBermudanEngine<CrankNicolson> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FDBermudanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDBermudanEngine< CrankNicolson > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FDBermudanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDBermudanEngine< CrankNicolson > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FDEuropeanEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FDEuropeanEngine< CrankNicolson > *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_FDEuropeanEngine" "', 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);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FDEuropeanEngine" "', 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_FDEuropeanEngine" "', 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 '" "new_FDEuropeanEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FDEuropeanEngine< CrankNicolson > *)new FDEuropeanEngine< CrankNicolson >(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<  FDEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDEuropeanEngine__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FDEuropeanEngine< CrankNicolson > *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_FDEuropeanEngine" "', 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);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FDEuropeanEngine" "', 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_FDEuropeanEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FDEuropeanEngine< CrankNicolson > *)new FDEuropeanEngine< CrankNicolson >(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<  FDEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDEuropeanEngine__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FDEuropeanEngine< CrankNicolson > *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_FDEuropeanEngine" "', 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);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FDEuropeanEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FDEuropeanEngine< CrankNicolson > *)new FDEuropeanEngine< CrankNicolson >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDEuropeanEngine__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  FDEuropeanEngine< CrankNicolson > *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_FDEuropeanEngine" "', 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 = (FDEuropeanEngine< CrankNicolson > *)new FDEuropeanEngine< CrankNicolson >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDEuropeanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FDEuropeanEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FDEuropeanEngine__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_FDEuropeanEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_FDEuropeanEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FDEuropeanEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FDEuropeanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FDEuropeanEngine< CrankNicolson >::FDEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const,Size,Size,bool)\n"
    "    FDEuropeanEngine< CrankNicolson >::FDEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const,Size,Size)\n"
    "    FDEuropeanEngine< CrankNicolson >::FDEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const,Size)\n"
    "    FDEuropeanEngine< CrankNicolson >::FDEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FDEuropeanEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FDEuropeanEngine< CrankNicolson > *arg1 = (FDEuropeanEngine< CrankNicolson > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FDEuropeanEngine< CrankNicolson > > tempshared1 ;
  ext::shared_ptr< FDEuropeanEngine< CrankNicolson > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FDEuropeanEngine" "', argument " "1"" of type '" "FDEuropeanEngine< CrankNicolson > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDEuropeanEngine< CrankNicolson > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FDEuropeanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDEuropeanEngine< CrankNicolson > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BinomialCRRVanillaEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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::PolynomType arg11 = (LsmBasisSystem::PolynomType) LsmBasisSystem::Monomial ;
  int arg12 = (int) 2048 ;
  boost::optional< bool > arg13 = (boost::optional< bool >) boost::none ;
  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::PolynomType""'");
    } 
    arg11 = static_cast< LsmBasisSystem::PolynomType >(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 = boost::none;
    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,arg2,arg3,arg4,arg5,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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::PolynomType arg11 = (LsmBasisSystem::PolynomType) LsmBasisSystem::Monomial ;
  int arg12 = (int) 2048 ;
  boost::optional< bool > arg13 = (boost::optional< bool >) boost::none ;
  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::PolynomType""'");
    } 
    arg11 = static_cast< LsmBasisSystem::PolynomType >(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 = boost::none;
    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,arg2,arg3,arg4,arg5,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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_FDAmericanEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FDAmericanEngine< CrankNicolson > *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_FDAmericanEngine" "', 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_FDAmericanEngine" "', 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_FDAmericanEngine" "', 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 '" "new_FDAmericanEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FDAmericanEngine< CrankNicolson > *)new FDAmericanEngine< CrankNicolson >((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<  FDAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDAmericanEngine__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  FDAmericanEngine< CrankNicolson > *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_FDAmericanEngine" "', 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_FDAmericanEngine" "', 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_FDAmericanEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FDAmericanEngine< CrankNicolson > *)new FDAmericanEngine< CrankNicolson >((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<  FDAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDAmericanEngine__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  FDAmericanEngine< CrankNicolson > *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_FDAmericanEngine" "', 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_FDAmericanEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FDAmericanEngine< CrankNicolson > *)new FDAmericanEngine< CrankNicolson >((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<  FDAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDAmericanEngine__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  FDAmericanEngine< CrankNicolson > *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_FDAmericanEngine" "', 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 = (FDAmericanEngine< CrankNicolson > *)new FDAmericanEngine< CrankNicolson >((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<  FDAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDAmericanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FDAmericanEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FDAmericanEngine__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_FDAmericanEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_FDAmericanEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FDAmericanEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FDAmericanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FDAmericanEngine< CrankNicolson >::FDAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,bool)\n"
    "    FDAmericanEngine< CrankNicolson >::FDAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FDAmericanEngine< CrankNicolson >::FDAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FDAmericanEngine< CrankNicolson >::FDAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FDAmericanEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FDAmericanEngine< CrankNicolson > *arg1 = (FDAmericanEngine< CrankNicolson > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FDAmericanEngine< CrankNicolson > > tempshared1 ;
  ext::shared_ptr< FDAmericanEngine< CrankNicolson > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FDAmericanEngine" "', argument " "1"" of type '" "FDAmericanEngine< CrankNicolson > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FDAmericanEngine<CrankNicolson> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FDAmericanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDAmericanEngine< CrankNicolson > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FDAmericanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDAmericanEngine< CrankNicolson > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FDShoutEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FDShoutEngine< CrankNicolson > *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_FDShoutEngine" "', 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_FDShoutEngine" "', 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_FDShoutEngine" "', 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 '" "new_FDShoutEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FDShoutEngine< CrankNicolson > *)new FDShoutEngine< CrankNicolson >((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<  FDShoutEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDShoutEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDShoutEngine__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  FDShoutEngine< CrankNicolson > *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_FDShoutEngine" "', 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_FDShoutEngine" "', 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_FDShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FDShoutEngine< CrankNicolson > *)new FDShoutEngine< CrankNicolson >((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<  FDShoutEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDShoutEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDShoutEngine__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  FDShoutEngine< CrankNicolson > *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_FDShoutEngine" "', 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_FDShoutEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FDShoutEngine< CrankNicolson > *)new FDShoutEngine< CrankNicolson >((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<  FDShoutEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDShoutEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDShoutEngine__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  FDShoutEngine< CrankNicolson > *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_FDShoutEngine" "', 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 = (FDShoutEngine< CrankNicolson > *)new FDShoutEngine< CrankNicolson >((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<  FDShoutEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDShoutEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDShoutEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FDShoutEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FDShoutEngine__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_FDShoutEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_FDShoutEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FDShoutEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FDShoutEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FDShoutEngine< CrankNicolson >::FDShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,bool)\n"
    "    FDShoutEngine< CrankNicolson >::FDShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FDShoutEngine< CrankNicolson >::FDShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FDShoutEngine< CrankNicolson >::FDShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FDShoutEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FDShoutEngine< CrankNicolson > *arg1 = (FDShoutEngine< CrankNicolson > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FDShoutEngine< CrankNicolson > > tempshared1 ;
  ext::shared_ptr< FDShoutEngine< CrankNicolson > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FDShoutEngine" "', argument " "1"" of type '" "FDShoutEngine< CrankNicolson > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FDShoutEngine<CrankNicolson> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FDShoutEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDShoutEngine< CrankNicolson > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FDShoutEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDShoutEngine< CrankNicolson > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ContinuousArithmeticAsianLevyEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BaroneAdesiWhaleyApproximationEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  AnalyticDividendEuropeanEngine *result = 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_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_delete_AnalyticDividendEuropeanEngine(PyObject *SWIGUNUSEDPARM(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_FDDividendEuropeanEngineT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FDDividendEuropeanEngine< CrankNicolson > *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_FDDividendEuropeanEngineT" "', 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_FDDividendEuropeanEngineT" "', 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_FDDividendEuropeanEngineT" "', 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 '" "new_FDDividendEuropeanEngineT" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FDDividendEuropeanEngine< CrankNicolson > *)new FDDividendEuropeanEngine< CrankNicolson >((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<  FDDividendEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendEuropeanEngineT__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  FDDividendEuropeanEngine< CrankNicolson > *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_FDDividendEuropeanEngineT" "', 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_FDDividendEuropeanEngineT" "', 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_FDDividendEuropeanEngineT" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FDDividendEuropeanEngine< CrankNicolson > *)new FDDividendEuropeanEngine< CrankNicolson >((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<  FDDividendEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendEuropeanEngineT__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  FDDividendEuropeanEngine< CrankNicolson > *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_FDDividendEuropeanEngineT" "', 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_FDDividendEuropeanEngineT" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FDDividendEuropeanEngine< CrankNicolson > *)new FDDividendEuropeanEngine< CrankNicolson >((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<  FDDividendEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendEuropeanEngineT__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  FDDividendEuropeanEngine< CrankNicolson > *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_FDDividendEuropeanEngineT" "', 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 = (FDDividendEuropeanEngine< CrankNicolson > *)new FDDividendEuropeanEngine< CrankNicolson >((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<  FDDividendEuropeanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendEuropeanEngineT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FDDividendEuropeanEngineT", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FDDividendEuropeanEngineT__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_FDDividendEuropeanEngineT__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_FDDividendEuropeanEngineT__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FDDividendEuropeanEngineT__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FDDividendEuropeanEngineT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FDDividendEuropeanEngine< CrankNicolson >::FDDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,bool)\n"
    "    FDDividendEuropeanEngine< CrankNicolson >::FDDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FDDividendEuropeanEngine< CrankNicolson >::FDDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FDDividendEuropeanEngine< CrankNicolson >::FDDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FDDividendEuropeanEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FDDividendEuropeanEngine< CrankNicolson > *arg1 = (FDDividendEuropeanEngine< CrankNicolson > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FDDividendEuropeanEngine< CrankNicolson > > tempshared1 ;
  ext::shared_ptr< FDDividendEuropeanEngine< CrankNicolson > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FDDividendEuropeanEngine" "', argument " "1"" of type '" "FDDividendEuropeanEngine< CrankNicolson > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDDividendEuropeanEngine< CrankNicolson > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FDDividendEuropeanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDDividendEuropeanEngine< CrankNicolson > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FDDividendAmericanEngineT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FDDividendAmericanEngine< CrankNicolson > *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_FDDividendAmericanEngineT" "', 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_FDDividendAmericanEngineT" "', 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_FDDividendAmericanEngineT" "', 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 '" "new_FDDividendAmericanEngineT" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FDDividendAmericanEngine< CrankNicolson > *)new FDDividendAmericanEngine< CrankNicolson >((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<  FDDividendAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendAmericanEngineT__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  FDDividendAmericanEngine< CrankNicolson > *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_FDDividendAmericanEngineT" "', 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_FDDividendAmericanEngineT" "', 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_FDDividendAmericanEngineT" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FDDividendAmericanEngine< CrankNicolson > *)new FDDividendAmericanEngine< CrankNicolson >((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<  FDDividendAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendAmericanEngineT__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  FDDividendAmericanEngine< CrankNicolson > *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_FDDividendAmericanEngineT" "', 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_FDDividendAmericanEngineT" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FDDividendAmericanEngine< CrankNicolson > *)new FDDividendAmericanEngine< CrankNicolson >((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<  FDDividendAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendAmericanEngineT__SWIG_3(PyObject *SWIGUNUSEDPARM(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 ;
  FDDividendAmericanEngine< CrankNicolson > *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_FDDividendAmericanEngineT" "', 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 = (FDDividendAmericanEngine< CrankNicolson > *)new FDDividendAmericanEngine< CrankNicolson >((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<  FDDividendAmericanEngine<CrankNicolson> > *smartresult = result ? new ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, SWIG_POINTER_OWN | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FDDividendAmericanEngineT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FDDividendAmericanEngineT", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FDDividendAmericanEngineT__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_FDDividendAmericanEngineT__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_FDDividendAmericanEngineT__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FDDividendAmericanEngineT__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FDDividendAmericanEngineT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FDDividendAmericanEngine< CrankNicolson >::FDDividendAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,bool)\n"
    "    FDDividendAmericanEngine< CrankNicolson >::FDDividendAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FDDividendAmericanEngine< CrankNicolson >::FDDividendAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FDDividendAmericanEngine< CrankNicolson >::FDDividendAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FDDividendAmericanEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FDDividendAmericanEngine< CrankNicolson > *arg1 = (FDDividendAmericanEngine< CrankNicolson > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FDDividendAmericanEngine< CrankNicolson > > tempshared1 ;
  ext::shared_ptr< FDDividendAmericanEngine< CrankNicolson > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FDDividendAmericanEngine" "', argument " "1"" of type '" "FDDividendAmericanEngine< CrankNicolson > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDDividendAmericanEngine< CrankNicolson > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FDDividendAmericanEngine<CrankNicolson> > * >(argp1);
      arg1 = const_cast< FDDividendAmericanEngine< CrankNicolson > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BarrierOption(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BarrierOption_impliedVolatility", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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);
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BarrierOption(PyObject *SWIGUNUSEDPARM(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_DividendBarrierOption(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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_FdmSchemeDesc(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_CrankNicolson(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ImplicitEuler(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ExplicitEuler(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_CraigSneyd(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ModifiedCraigSneyd(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_Hundsdorfer(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ModifiedHundsdorfer(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines__SWIG_0(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines__SWIG_2(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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(static_cast< const FdmSchemeDesc& >(result))), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmSchemeDesc(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesVanillaEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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;
    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 == 3) {
    int _v;
    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;
    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 == 4) {
    int _v;
    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;
    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 == 5) {
    int _v;
    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;
    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 == 6) {
    int _v;
    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;
    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 == 7) {
    int _v;
    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;
    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 == 8) {
    int _v;
    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;
    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 == 9) {
    int _v;
    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);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdBlackScholesVanillaEngine_make(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > const &arg2_defvalue = ext::shared_ptr< FdmQuantoHelper >() ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = (ext::shared_ptr< FdmQuantoHelper > *) &arg2_defvalue ;
  Size arg3 = (Size) 100 ;
  Size arg4 = (Size) 100 ;
  Size arg5 = (Size) 0 ;
  FdmSchemeDesc const &arg6_defvalue = FdmSchemeDesc::Douglas() ;
  FdmSchemeDesc *arg6 = (FdmSchemeDesc *) &arg6_defvalue ;
  bool arg7 = (bool) false ;
  Real arg8 = (Real) -Null< Real >() ;
  FdBlackScholesVanillaEngine::CashDividendModel arg9 = (FdBlackScholesVanillaEngine::CashDividendModel) FdBlackScholesVanillaEngine::Spot ;
  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 ;
  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 *)"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|OOOOOOOO:FdBlackScholesVanillaEngine_make", 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 '" "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) {
    {
      int newmem = 0;
      res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdBlackScholesVanillaEngine_make" "', 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;
      }
    }
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_size_t(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "3"" of type '" "Size""'");
    } 
    arg3 = static_cast< Size >(val3);
  }
  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) {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
    }
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
    }
    arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_bool(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "7"" of type '" "bool""'");
    } 
    arg7 = static_cast< bool >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "8"" of type '" "Real""'");
    } 
    arg8 = static_cast< Real >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "9"" of type '" "FdBlackScholesVanillaEngine::CashDividendModel""'");
    } 
    arg9 = static_cast< FdBlackScholesVanillaEngine::CashDividendModel >(val9);
  }
  {
    try {
      result = FdBlackScholesVanillaEngine_make((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) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesVanillaEngine(PyObject *SWIGUNUSEDPARM(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_FdOrnsteinUhlenbeckVanillaEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdOrnsteinUhlenbeckVanillaEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    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;
    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 == 4) {
    int _v;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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);
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdOrnsteinUhlenbeckVanillaEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBatesVanillaEngine", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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 == 3) {
    int _v;
    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 == 4) {
    int _v;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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);
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBatesVanillaEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonVanillaEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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;
    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 == 3) {
    int _v;
    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;
    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 == 4) {
    int _v;
    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;
    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 == 5) {
    int _v;
    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;
    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 == 6) {
    int _v;
    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;
    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 == 7) {
    int _v;
    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;
    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 == 8) {
    int _v;
    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;
    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 == 9) {
    int _v;
    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);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdHestonVanillaEngine_make(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > const &arg2_defvalue = ext::shared_ptr< FdmQuantoHelper >() ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = (ext::shared_ptr< FdmQuantoHelper > *) &arg2_defvalue ;
  Size arg3 = (Size) 100 ;
  Size arg4 = (Size) 100 ;
  Size arg5 = (Size) 50 ;
  Size arg6 = (Size) 0 ;
  FdmSchemeDesc const &arg7_defvalue = FdmSchemeDesc::Hundsdorfer() ;
  FdmSchemeDesc *arg7 = (FdmSchemeDesc *) &arg7_defvalue ;
  ext::shared_ptr< LocalVolTermStructure > const &arg8_defvalue = ext::shared_ptr< LocalVolTermStructure >() ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = (ext::shared_ptr< LocalVolTermStructure > *) &arg8_defvalue ;
  Real arg9 = (Real) (Real)1.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 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"model",  (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|OOOOOOOO:FdHestonVanillaEngine_make", 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_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) {
    {
      int newmem = 0;
      res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdHestonVanillaEngine_make" "', 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;
      }
    }
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_size_t(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdHestonVanillaEngine_make" "', argument " "3"" of type '" "Size""'");
    } 
    arg3 = static_cast< Size >(val3);
  }
  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) {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FdHestonVanillaEngine_make" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdHestonVanillaEngine_make" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
    }
    arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  }
  if (obj7) {
    {
      int newmem = 0;
      res8 = SWIG_ConvertPtrAndOwn(obj7, &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "FdHestonVanillaEngine_make" "', 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;
      }
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_double(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FdHestonVanillaEngine_make" "', argument " "9"" of type '" "Real""'");
    } 
    arg9 = static_cast< Real >(val9);
  }
  {
    try {
      result = FdHestonVanillaEngine_make((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) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonVanillaEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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_FdBlackScholesBarrierEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesBarrierEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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 == 3) {
    int _v;
    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 == 4) {
    int _v;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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);
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesBarrierEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesRebateEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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 == 3) {
    int _v;
    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 == 4) {
    int _v;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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);
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesRebateEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonBarrierEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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 == 3) {
    int _v;
    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 == 4) {
    int _v;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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 == 8) {
    int _v;
    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);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonBarrierEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonRebateEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    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;
    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 == 3) {
    int _v;
    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 == 4) {
    int _v;
    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 == 5) {
    int _v;
    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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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 == 8) {
    int _v;
    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);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonRebateEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_ForwardEuropeanEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_BlackCalculator__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_alpha(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Average(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Average::Type arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< Date,std::allocator< Date > > *arg4 = 0 ;
  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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< Exercise > tempshared6 ;
  PyObject *swig_obj[6] ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DiscreteAveragingAsianOption", 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_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;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscreteAveragingAsianOption" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg4 = 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,(std::vector< Date,std::allocator< Date > > const &)*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);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DiscreteAveragingAsianOption(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_AnalyticDiscreteGeometricAveragePriceAsianEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_AnalyticDiscreteGeometricAverageStrikeAsianEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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_MCPRDiscreteArithmeticASEngine(PyObject *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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_VarianceGammaEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_DoubleBarrierOption(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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_WulinYongDoubleBarrierEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  WulinYongDoubleBarrierEngine *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_WulinYongDoubleBarrierEngine" "', 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_WulinYongDoubleBarrierEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (WulinYongDoubleBarrierEngine *)new WulinYongDoubleBarrierEngine((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<  WulinYongDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  WulinYongDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WulinYongDoubleBarrierEngine__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  WulinYongDoubleBarrierEngine *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_WulinYongDoubleBarrierEngine" "', 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 = (WulinYongDoubleBarrierEngine *)new WulinYongDoubleBarrierEngine((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<  WulinYongDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  WulinYongDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WulinYongDoubleBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_WulinYongDoubleBarrierEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WulinYongDoubleBarrierEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    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_WulinYongDoubleBarrierEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WulinYongDoubleBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    WulinYongDoubleBarrierEngine::WulinYongDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,int)\n"
    "    WulinYongDoubleBarrierEngine::WulinYongDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WulinYongDoubleBarrierEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  WulinYongDoubleBarrierEngine *arg1 = (WulinYongDoubleBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< WulinYongDoubleBarrierEngine > tempshared1 ;
  ext::shared_ptr< WulinYongDoubleBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WulinYongDoubleBarrierEngine" "', argument " "1"" of type '" "WulinYongDoubleBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  WulinYongDoubleBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  WulinYongDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< WulinYongDoubleBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  WulinYongDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< WulinYongDoubleBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DeltaVolQuote__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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_delete_DeltaVolQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_value(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_VannaVolgaIKDoubleBarrierEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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< WulinYongDoubleBarrierEngine > *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< WulinYongDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine >(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<WulinYongDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_1(PyObject *SWIGUNUSEDPARM(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< WulinYongDoubleBarrierEngine > *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< WulinYongDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine >(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<WulinYongDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_2(PyObject *SWIGUNUSEDPARM(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< WulinYongDoubleBarrierEngine > *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< WulinYongDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine >(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<WulinYongDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_3(PyObject *SWIGUNUSEDPARM(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< WulinYongDoubleBarrierEngine > *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< WulinYongDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine >(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<WulinYongDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_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;
    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;
    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;
    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;
    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< WulinYongDoubleBarrierEngine >::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< WulinYongDoubleBarrierEngine >::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< WulinYongDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const)\n"
    "    VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine >::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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > *arg1 = (VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > > tempshared1 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > > *smartarg1 = 0 ;
  PyObject *swig_obj[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_WulinYongDoubleBarrierEngine_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> > * >(argp1);
      arg1 = const_cast< VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<WulinYongDoubleBarrierEngine> > * >(argp1);
      arg1 = const_cast< VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_WulinYongDoubleBarrierEngine_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_VannaVolgaBarrierEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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_AnalyticDoubleBarrierBinaryEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_VanillaSwingOption(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3,arg4,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 *SWIGUNUSEDPARM(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,arg3,arg4,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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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_new_GJRGARCHModel(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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_SpreadOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadOption" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadOption" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'"); 
  }
  arg1 = reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_PlainVanillaPayoff(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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::PolynomType arg12 = (LsmBasisSystem::PolynomType) 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::PolynomType""'");
    } 
    arg12 = static_cast< LsmBasisSystem::PolynomType >(val12);
  }
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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::PolynomType arg12 = (LsmBasisSystem::PolynomType) 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::PolynomType""'");
    } 
    arg12 = static_cast< LsmBasisSystem::PolynomType >(val12);
  }
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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<  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CallabilityPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  CallabilityPrice::Type arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CallabilityPrice *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CallabilityPrice", 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_CallabilityPrice" "', 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_CallabilityPrice" "', argument " "2"" of type '" "CallabilityPrice::Type""'");
  } 
  arg2 = static_cast< CallabilityPrice::Type >(val2);
  {
    try {
      result = (CallabilityPrice *)new CallabilityPrice(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CallabilityPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilityPrice_amount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallabilityPrice *arg1 = (CallabilityPrice *) 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_CallabilityPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilityPrice_amount" "', argument " "1"" of type '" "CallabilityPrice const *""'"); 
  }
  arg1 = reinterpret_cast< CallabilityPrice * >(argp1);
  {
    try {
      result = (Real)((CallabilityPrice 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_CallabilityPrice_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallabilityPrice *arg1 = (CallabilityPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CallabilityPrice::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CallabilityPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilityPrice_type" "', argument " "1"" of type '" "CallabilityPrice const *""'"); 
  }
  arg1 = reinterpret_cast< CallabilityPrice * >(argp1);
  {
    try {
      result = (CallabilityPrice::Type)((CallabilityPrice 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_CallabilityPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallabilityPrice *arg1 = (CallabilityPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CallabilityPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallabilityPrice" "', argument " "1"" of type '" "CallabilityPrice *""'"); 
  }
  arg1 = reinterpret_cast< CallabilityPrice * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Callability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallabilityPrice *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_CallabilityPrice,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Callability" "', argument " "1"" of type '" "CallabilityPrice const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Callability" "', argument " "1"" of type '" "CallabilityPrice const &""'"); 
  }
  arg1 = reinterpret_cast< CallabilityPrice * >(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((CallabilityPrice 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 *SWIGUNUSEDPARM(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] ;
  CallabilityPrice *result = 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 = (CallabilityPrice *) &((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_CallabilityPrice, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callability_type(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Callability(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallabilityPrice *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_CallabilityPrice,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoftCallability" "', argument " "1"" of type '" "CallabilityPrice const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SoftCallability" "', argument " "1"" of type '" "CallabilityPrice const &""'"); 
  }
  arg1 = reinterpret_cast< CallabilityPrice * >(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((CallabilityPrice 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)\n"
    "    std::vector< ext::shared_ptr< Callability > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_TimeBasket__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject *swig_obj[2] ;
  Swap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Swap", 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_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_Swap_startDate(PyObject *SWIGUNUSEDPARM(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] ;
  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 *""'");
    }
    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 {
      result = (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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_maturityDate(PyObject *SWIGUNUSEDPARM(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] ;
  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 *""'");
    }
    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 {
      result = (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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_leg(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_Swap(PyObject *SWIGUNUSEDPARM(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_new_VanillaSwap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap::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 ;
  PyObject *swig_obj[9] ;
  VanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VanillaSwap", 9, 9, 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_VanillaSwap" "', argument " "1"" of type '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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(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_VanillaSwap_fairRate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg2 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new__MakeVanillaSwap(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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;
    {
      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;
    {
      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;
    {
      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;
    {
      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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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 *SWIGUNUSEDPARM(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] ;
  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_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 = (VanillaSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaSwap::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 '" "VanillaSwap::Type""'");
  } 
  arg1 = static_cast< VanillaSwap::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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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(VanillaSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 ;
  Natural 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 ;
  unsigned 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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(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_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap::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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg1 = static_cast< OvernightIndexedSwap::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(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexedSwap", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v;
    {
      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_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_OvernightIndexedSwap__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_OvernightIndexedSwap__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_unsigned_SS_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_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_unsigned_SS_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_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_unsigned_SS_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_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_unsigned_SS_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_7(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_unsigned_SS_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_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_unsigned_SS_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_6(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(OvernightIndexedSwap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural,BusinessDayConvention,Calendar,bool)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural,BusinessDayConvention,Calendar)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural,BusinessDayConvention)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural,BusinessDayConvention,Calendar,bool)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural,BusinessDayConvention,Calendar)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural,BusinessDayConvention)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Natural)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(OvernightIndexedSwap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fixedLegBPS(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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] ;
  OvernightIndexedSwap::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 = (OvernightIndexedSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_spread(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_OvernightIndexedSwap(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  OvernightIndexedSwap::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 '" "OvernightIndexedSwap::Type""'");
  } 
  arg2 = static_cast< OvernightIndexedSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_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_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withPaymentLag" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_withPricingEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexedSwapIndex", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_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_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_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_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)\n"
    "    OvernightIndexedSwapIndex::OvernightIndexedSwapIndex(std::string const &,Period const &,Natural,Currency,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwapIndex_overnightIndex(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Seasonality_correctZeroRate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_frequency(PyObject *SWIGUNUSEDPARM(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_indexIsInterpolated(PyObject *SWIGUNUSEDPARM(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_indexIsInterpolated" "', 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)->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_InflationTermStructure_baseRate(PyObject *SWIGUNUSEDPARM(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_nominalTermStructure(PyObject *SWIGUNUSEDPARM(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] ;
  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_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_nominalTermStructure" "', 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)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_baseDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_setSeasonality__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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_delete_YoYInflationTermStructure(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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_observationLag(PyObject *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_frequency(PyObject *SWIGUNUSEDPARM(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_indexIsInterpolated(PyObject *SWIGUNUSEDPARM(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_baseRate(PyObject *SWIGUNUSEDPARM(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_nominalTermStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > 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_nominalTermStructure" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_baseDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_setSeasonality__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_frequency(PyObject *SWIGUNUSEDPARM(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_indexIsInterpolated(PyObject *SWIGUNUSEDPARM(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_indexIsInterpolated" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(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_ZeroInflationTermStructureHandle_baseRate(PyObject *SWIGUNUSEDPARM(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_nominalTermStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > 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_nominalTermStructure" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->nominalTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_baseDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_setSeasonality__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Region& >(result))), SWIGTYPE_p_Region, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_revised(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_currency(PyObject *SWIGUNUSEDPARM(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(static_cast< const Currency& >(result))), SWIGTYPE_p_Currency, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InflationIndex(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 7) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_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_0(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,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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< ZeroInflationTermStructure >& >(result))), SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationIndex_clone(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_YoYInflationIndex__SWIG_0(PyObject *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 8) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_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_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_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_0(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(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 *SWIGUNUSEDPARM(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_yoyInflationTermStructure(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YoYInflationTermStructure >& >(result))), SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationIndex_clone(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EUHICP__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_0(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(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    EUHICP::EUHICP(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EUHICP(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EUHICPXT__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_0(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(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    EUHICPXT::EUHICPXT(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EUHICPXT(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FRHICP__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_0(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(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    FRHICP::FRHICP(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FRHICP(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UKRPI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_0(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(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    UKRPI::UKRPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UKRPI(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_USCPI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_0(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(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    USCPI::USCPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_USCPI(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ZACPI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_0(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(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    ZACPI::ZACPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZACPI(PyObject *SWIGUNUSEDPARM(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_YYEUHICP__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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 == 3) {
    int _v;
    {
      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_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_0(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,bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    AUCPI::AUCPI(Frequency,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AUCPI(PyObject *SWIGUNUSEDPARM(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_new_CPI(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationCoupon_fixingDays(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Period& >(result))), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationCoupon_indexFixing(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CPICoupon_fixedRate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_adjustedFixing(PyObject *SWIGUNUSEDPARM(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_adjustedFixing" "', 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)->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_CPICoupon_baseCPI(PyObject *SWIGUNUSEDPARM(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_observationInterpolation(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_CPICoupon(PyObject *SWIGUNUSEDPARM(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 *_wrap_as_cpi_coupon(PyObject *SWIGUNUSEDPARM(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_ZeroHelper_quote(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_latestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_earliestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_latestRelevantDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_pillarDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_impliedQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_latestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_earliestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_latestRelevantDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_pillarDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_impliedQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_latestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_earliestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_latestRelevantDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_pillarDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_impliedQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  ZeroCouponInflationSwapHelper *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_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;
    }
  }
  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_ZeroCouponInflationSwapHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    try {
      result = (ZeroCouponInflationSwapHelper *)new_ZeroCouponInflationSwapHelper__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > 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<  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_new_ZeroCouponInflationSwapHelper__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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 ;
  ZeroCouponInflationSwapHelper *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_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;
    }
  }
  {
    try {
      result = (ZeroCouponInflationSwapHelper *)new_ZeroCouponInflationSwapHelper__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > 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<  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_new_ZeroCouponInflationSwapHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroCouponInflationSwapHelper", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v;
    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_Date, 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_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_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ZeroCouponInflationSwapHelper__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_Date, 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_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_ZeroInflationIndex_t, 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_ZeroCouponInflationSwapHelper__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroCouponInflationSwapHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroCouponInflationSwapHelper::ZeroCouponInflationSwapHelper(Handle< Quote > const &,Period const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,ext::shared_ptr< ZeroInflationIndex > const &,Handle< YieldTermStructure > const &)\n"
    "    ZeroCouponInflationSwapHelper::ZeroCouponInflationSwapHelper(Handle< Quote > const &,Period const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,ext::shared_ptr< ZeroInflationIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZeroCouponInflationSwapHelper(PyObject *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  YearOnYearInflationSwapHelper *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_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__SWIG_0((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_new_YearOnYearInflationSwapHelper__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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 ;
  YearOnYearInflationSwapHelper *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_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;
    }
  }
  {
    try {
      result = (YearOnYearInflationSwapHelper *)new_YearOnYearInflationSwapHelper__SWIG_0((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< YoYInflationIndex > 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<  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_new_YearOnYearInflationSwapHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YearOnYearInflationSwapHelper", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v;
    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_Date, 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_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_YoYInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_YearOnYearInflationSwapHelper__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_Date, 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_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_YoYInflationIndex_t, 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_YearOnYearInflationSwapHelper__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YearOnYearInflationSwapHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YearOnYearInflationSwapHelper::YearOnYearInflationSwapHelper(Handle< Quote > const &,Period const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,ext::shared_ptr< YoYInflationIndex > const &,Handle< YieldTermStructure > const &)\n"
    "    YearOnYearInflationSwapHelper::YearOnYearInflationSwapHelper(Handle< Quote > const &,Period const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,ext::shared_ptr< YoYInflationIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YearOnYearInflationSwapHelper(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *arg9 = 0 ;
  Real arg10 = (Real) 1.0e-12 ;
  Linear const &arg11_defvalue = Linear() ;
  Linear *arg11 = (Linear *) &arg11_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 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  char * kwnames[] = {
    (char *)"referenceDate",  (char *)"calendar",  (char *)"dayCounter",  (char *)"lag",  (char *)"frequency",  (char *)"indexIsInterpolated",  (char *)"baseRate",  (char *)"nominalTS",  (char *)"instruments",  (char *)"accuracy",  (char *)"i",  NULL 
  };
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO|OO:new_PiecewiseZeroInflation", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) 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_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(obj1, &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(obj2, &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(obj3, &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(obj4, &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_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseZeroInflation" "', 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_PiecewiseZeroInflation" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseZeroInflation" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    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;
    res9 = swig::asptr(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseZeroInflation" "', argument " "9"" 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 " "9"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_double(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_PiecewiseZeroInflation" "', argument " "10"" of type '" "Real""'");
    } 
    arg10 = static_cast< Real >(val10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Linear,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_PiecewiseZeroInflation" "', argument " "11"" of type '" "Linear const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "11"" of type '" "Linear const &""'"); 
    }
    arg11 = reinterpret_cast< Linear * >(argp11);
  }
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)*arg9,arg10,(Linear 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<  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(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseZeroInflation_dates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *arg9 = 0 ;
  Real arg10 = (Real) 1.0e-12 ;
  Linear const &arg11_defvalue = Linear() ;
  Linear *arg11 = (Linear *) &arg11_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 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  char * kwnames[] = {
    (char *)"referenceDate",  (char *)"calendar",  (char *)"dayCounter",  (char *)"lag",  (char *)"frequency",  (char *)"indexIsInterpolated",  (char *)"baseRate",  (char *)"nominalTS",  (char *)"instruments",  (char *)"accuracy",  (char *)"i",  NULL 
  };
  PiecewiseYoYInflationCurve< Linear > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO|OO:new_PiecewiseYoYInflation", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) 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);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseYoYInflation" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    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;
    res9 = swig::asptr(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseYoYInflation" "', argument " "9"" 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 " "9"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_double(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_PiecewiseYoYInflation" "', argument " "10"" of type '" "Real""'");
    } 
    arg10 = static_cast< Real >(val10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Linear,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_PiecewiseYoYInflation" "', argument " "11"" of type '" "Linear const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "11"" of type '" "Linear const &""'"); 
    }
    arg11 = reinterpret_cast< Linear * >(argp11);
  }
  {
    try {
      result = (PiecewiseYoYInflationCurve< Linear > *)new PiecewiseYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(Handle< YieldTermStructure > const &)*arg8,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)*arg9,arg10,(Linear 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<  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(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseYoYInflation_dates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_inflationBaseDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_yoyInflationLeg(PyObject *SWIGUNUSEDPARM(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_ZeroCouponInflationSwap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap::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 ;
  bool arg11 ;
  SwigValueWrapper< Calendar > arg12 ;
  BusinessDayConvention 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 ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  int val13 ;
  int ecode13 = 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 '" "ZeroCouponInflationSwap::Type""'");
  } 
  arg1 = static_cast< ZeroCouponInflationSwap::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_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(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_ZeroCouponInflationSwap" "', argument " "12"" of type '" "Calendar""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "12"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) delete temp;
    }
  }
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZeroCouponInflationSwap" "', argument " "13"" of type '" "BusinessDayConvention""'");
  } 
  arg13 = static_cast< BusinessDayConvention >(val13);
  {
    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_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap::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 ;
  bool arg11 ;
  SwigValueWrapper< Calendar > 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 ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 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 '" "ZeroCouponInflationSwap::Type""'");
  } 
  arg1 = static_cast< ZeroCouponInflationSwap::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_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(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_ZeroCouponInflationSwap" "', argument " "12"" of type '" "Calendar""'"); 
    }  
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "12"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp12);
      arg12 = *temp;
      if (SWIG_IsNewObj(res12)) 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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap::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 ;
  bool 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 ;
  bool 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 '" "ZeroCouponInflationSwap::Type""'");
  } 
  arg1 = static_cast< ZeroCouponInflationSwap::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_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(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__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap::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 ;
  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 ;
  ZeroCouponInflationSwap *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_ZeroCouponInflationSwap" "', argument " "1"" of type '" "ZeroCouponInflationSwap::Type""'");
  } 
  arg1 = static_cast< ZeroCouponInflationSwap::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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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[14] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroCouponInflationSwap", 0, 13, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v;
    {
      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) {
                        return _wrap_new_ZeroCouponInflationSwap__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZeroCouponInflationSwap__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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_bool(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_ZeroCouponInflationSwap__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      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_bool(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_int(argv[12], 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(ZeroCouponInflationSwap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,bool,Calendar,BusinessDayConvention)\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(ZeroCouponInflationSwap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,bool,Calendar)\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(ZeroCouponInflationSwap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,bool)\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(ZeroCouponInflationSwap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_fairRate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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] ;
  ZeroCouponInflationSwap::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 = (ZeroCouponInflationSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap::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 '" "YearOnYearInflationSwap::Type""'");
  } 
  arg1 = static_cast< YearOnYearInflationSwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap::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 '" "YearOnYearInflationSwap::Type""'");
  } 
  arg1 = static_cast< YearOnYearInflationSwap::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;
    {
      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;
    {
      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(YearOnYearInflationSwap::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(YearOnYearInflationSwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CPISwap::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 '" "CPISwap::Type""'");
  } 
  arg1 = static_cast< CPISwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CPISwap::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 '" "CPISwap::Type""'");
  } 
  arg1 = static_cast< CPISwap::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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CPISwap::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 '" "CPISwap::Type""'");
  } 
  arg1 = static_cast< CPISwap::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;
    {
      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;
    {
      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;
    {
      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(CPISwap::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(CPISwap::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(CPISwap::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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg8 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  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 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  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 *)"yTS",  (char *)"dates",  (char *)"rates",  (char *)"interpolator",  NULL 
  };
  InterpolatedZeroInflationCurve< Linear > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO|O:new_ZeroInflationCurve", 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_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(obj1, &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(obj2, &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(obj3, &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(obj4, &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);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroInflationCurve" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationCurve" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res8 = swig::asptr(obj7, &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ZeroInflationCurve" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', 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(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ZeroInflationCurve" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  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_ZeroInflationCurve" "', argument " "10"" of type '" "Linear const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "10"" of type '" "Linear const &""'"); 
    }
    arg10 = reinterpret_cast< Linear * >(argp10);
  }
  {
    try {
      result = (InterpolatedZeroInflationCurve< Linear > *)new InterpolatedZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(Handle< YieldTermStructure > const &)*arg7,(std::vector< Date,std::allocator< Date > > const &)*arg8,(std::vector< Rate,std::allocator< Rate > > const &)*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<  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(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_ZeroInflationCurve_dates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg8 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  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 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  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 *)"yTS",  (char *)"dates",  (char *)"rates",  (char *)"interpolator",  NULL 
  };
  InterpolatedYoYInflationCurve< Linear > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO|O:new_YoYInflationCurve", 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_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);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCurve" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)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< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', 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(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_YoYInflationCurve" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  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_YoYInflationCurve" "', argument " "10"" of type '" "Linear const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "10"" of type '" "Linear const &""'"); 
    }
    arg10 = reinterpret_cast< Linear * >(argp10);
  }
  {
    try {
      result = (InterpolatedYoYInflationCurve< Linear > *)new InterpolatedYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(Handle< YieldTermStructure > const &)*arg7,(std::vector< Date,std::allocator< Date > > const &)*arg8,(std::vector< Rate,std::allocator< Rate > > const &)*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<  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(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_YoYInflationCurve_dates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 > > >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_maxMaturity(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYCapFloorTermPriceSurface(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Matrix temp13 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg12 = &temp12;
    } else {
      SWIG_ConvertPtr(swig_obj[11],(void **) &arg12,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg13 = &temp13;
    } else {
      SWIG_ConvertPtr(swig_obj[12],(void **) &arg13,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  Matrix temp13 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg12 = &temp12;
    } else {
      SWIG_ConvertPtr(swig_obj[11],(void **) &arg12,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg13 = &temp13;
    } else {
      SWIG_ConvertPtr(swig_obj[12],(void **) &arg13,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  Matrix temp13 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg12 = &temp12;
    } else {
      SWIG_ConvertPtr(swig_obj[11],(void **) &arg12,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg13 = &temp13;
    } else {
      SWIG_ConvertPtr(swig_obj[12],(void **) &arg13,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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;
    {
      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 {
                              Matrix* m;
                              if (SWIG_ConvertPtr(argv[11],(void **) &m,
                                  SWIGTYPE_p_Matrix,0) != -1)
                              _v = 1;
                              else
                              _v = 0;
                            }
                          }
                          if (_v) {
                            {
                              /* native sequence? */
                              if (PyTuple_Check(argv[12]) || PyList_Check(argv[12])) {
                                _v = 1;
                                /* wrapped Matrix? */
                              } else {
                                Matrix* m;
                                if (SWIG_ConvertPtr(argv[12],(void **) &m,
                                    SWIGTYPE_p_Matrix,0) != -1)
                                _v = 1;
                                else
                                _v = 0;
                              }
                            }
                            if (_v) {
                              return _wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      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 {
                              Matrix* m;
                              if (SWIG_ConvertPtr(argv[11],(void **) &m,
                                  SWIGTYPE_p_Matrix,0) != -1)
                              _v = 1;
                              else
                              _v = 0;
                            }
                          }
                          if (_v) {
                            {
                              /* native sequence? */
                              if (PyTuple_Check(argv[12]) || PyList_Check(argv[12])) {
                                _v = 1;
                                /* wrapped Matrix? */
                              } else {
                                Matrix* m;
                                if (SWIG_ConvertPtr(argv[12],(void **) &m,
                                    SWIGTYPE_p_Matrix,0) != -1)
                                _v = 1;
                                else
                                _v = 0;
                              }
                            }
                            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;
    {
      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 {
                              Matrix* m;
                              if (SWIG_ConvertPtr(argv[11],(void **) &m,
                                  SWIGTYPE_p_Matrix,0) != -1)
                              _v = 1;
                              else
                              _v = 0;
                            }
                          }
                          if (_v) {
                            {
                              /* native sequence? */
                              if (PyTuple_Check(argv[12]) || PyList_Check(argv[12])) {
                                _v = 1;
                                /* wrapped Matrix? */
                              } else {
                                Matrix* m;
                                if (SWIG_ConvertPtr(argv[12],(void **) &m,
                                    SWIGTYPE_p_Matrix,0) != -1)
                                _v = 1;
                                else
                                _v = 0;
                              }
                            }
                            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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_calibrate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[3],&arg4)) {
      ;
    } else {
      if (SWIG_ConvertPtr(swig_obj[3],(void **) &v4, SWIGTYPE_p_Array,1) != -1)
      arg4 = *v4;
      else {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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;
    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;
    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 {
              /* wrapped Array? */
              Array* v;
              if (SWIG_ConvertPtr(argv[3],(void **) &v,
                  SWIGTYPE_p_Array,0) != -1)
              _v = 1;
              else
              _v = 0;
            }
          }
          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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Bond__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_settlementDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_issueDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_cashflows(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_notionals(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_cleanPriceFromZSpread__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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_new_ZeroCouponBond(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  bool arg13 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  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_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);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &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);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &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_new_FixedRateBond__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  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_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);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_FixedRateBond__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  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_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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_FixedRateBond__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Calendar *arg9 = 0 ;
  Period *arg10 = 0 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_FixedRateBond__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Calendar *arg9 = 0 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    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_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;
    }
  }
  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_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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_FixedRateBond__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    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_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;
    }
  }
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > const &)*arg4,(DayCounter 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<  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_new_FixedRateBond__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &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);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > 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<  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_new_FixedRateBond__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > 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<  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_new_FixedRateBond__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  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 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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(swig_obj[3], &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(swig_obj[4], &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);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > 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<  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_new_FixedRateBond__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  bool arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(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_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(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_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(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_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(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_FixedRateBond" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', argument " "11"" of type '" "BusinessDayConvention""'");
  } 
  arg11 = static_cast< BusinessDayConvention >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FixedRateBond" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*arg9,(Calendar 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<  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_new_FixedRateBond__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(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_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(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_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(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_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(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_FixedRateBond" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', argument " "11"" of type '" "BusinessDayConvention""'");
  } 
  arg11 = static_cast< BusinessDayConvention >(val11);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*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");
    }
  }
  {
    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_new_FixedRateBond__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(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_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(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_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(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_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(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_FixedRateBond" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period 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<  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_new_FixedRateBond__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Period *arg9 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(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_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(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_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(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_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar 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<  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_new_FixedRateBond__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(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_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(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_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(argp8);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4,arg5,arg6,(Date const &)*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<  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_new_FixedRateBond__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  Date *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(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_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > 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<  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_new_FixedRateBond__SWIG_15(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Real arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > 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<  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_new_FixedRateBond__SWIG_16(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > 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<  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_new_FixedRateBond__SWIG_17(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', 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_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< 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 '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< 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");
    }
  }
  {
    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_new_FixedRateBond__SWIG_18(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  Period *arg17 = 0 ;
  Calendar *arg18 = 0 ;
  BusinessDayConvention arg19 ;
  bool arg20 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  bool val20 ;
  int ecode20 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  arg16 = reinterpret_cast< Calendar * >(argp16);
  res17 = SWIG_ConvertPtr(swig_obj[16], &argp17, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  arg17 = reinterpret_cast< Period * >(argp17);
  res18 = SWIG_ConvertPtr(swig_obj[17], &argp18, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FixedRateBond" "', argument " "18"" of type '" "Calendar const &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "18"" of type '" "Calendar const &""'"); 
  }
  arg18 = reinterpret_cast< Calendar * >(argp18);
  ecode19 = SWIG_AsVal_int(swig_obj[18], &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_FixedRateBond" "', argument " "19"" of type '" "BusinessDayConvention""'");
  } 
  arg19 = static_cast< BusinessDayConvention >(val19);
  ecode20 = SWIG_AsVal_bool(swig_obj[19], &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "new_FixedRateBond" "', argument " "20"" of type '" "bool""'");
  } 
  arg20 = static_cast< bool >(val20);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,arg14,arg15,(Calendar const &)*arg16,(Period const &)*arg17,(Calendar const &)*arg18,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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_19(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  Period *arg17 = 0 ;
  Calendar *arg18 = 0 ;
  BusinessDayConvention arg19 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  arg16 = reinterpret_cast< Calendar * >(argp16);
  res17 = SWIG_ConvertPtr(swig_obj[16], &argp17, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  arg17 = reinterpret_cast< Period * >(argp17);
  res18 = SWIG_ConvertPtr(swig_obj[17], &argp18, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FixedRateBond" "', argument " "18"" of type '" "Calendar const &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "18"" of type '" "Calendar const &""'"); 
  }
  arg18 = reinterpret_cast< Calendar * >(argp18);
  ecode19 = SWIG_AsVal_int(swig_obj[18], &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_FixedRateBond" "', argument " "19"" of type '" "BusinessDayConvention""'");
  } 
  arg19 = static_cast< BusinessDayConvention >(val19);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,arg14,arg15,(Calendar const &)*arg16,(Period const &)*arg17,(Calendar 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_20(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  Period *arg17 = 0 ;
  Calendar *arg18 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  arg16 = reinterpret_cast< Calendar * >(argp16);
  res17 = SWIG_ConvertPtr(swig_obj[16], &argp17, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  arg17 = reinterpret_cast< Period * >(argp17);
  res18 = SWIG_ConvertPtr(swig_obj[17], &argp18, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FixedRateBond" "', argument " "18"" of type '" "Calendar const &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "18"" of type '" "Calendar const &""'"); 
  }
  arg18 = reinterpret_cast< Calendar * >(argp18);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,arg14,arg15,(Calendar const &)*arg16,(Period const &)*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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_21(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  Period *arg17 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  arg16 = reinterpret_cast< Calendar * >(argp16);
  res17 = SWIG_ConvertPtr(swig_obj[16], &argp17, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "17"" of type '" "Period const &""'"); 
  }
  arg17 = reinterpret_cast< Period * >(argp17);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,arg14,arg15,(Calendar const &)*arg16,(Period 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_22(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
  }
  arg16 = reinterpret_cast< Calendar * >(argp16);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_23(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  bool arg15 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_24(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  DateGeneration::Rule arg14 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBond" "', argument " "14"" of type '" "DateGeneration::Rule""'");
  } 
  arg14 = static_cast< DateGeneration::Rule >(val14);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_25(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_26(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(DayCounter const &)*arg8,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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_27(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  Real arg11 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FixedRateBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_28(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  BusinessDayConvention arg10 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_29(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond__SWIG_30(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FixedRateBond *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_FixedRateBond" "', 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_FixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', 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_FixedRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', 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_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  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_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< Rate,std::allocator< Rate > > 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<  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(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FixedRateBond", 0, 20, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FixedRateBond__SWIG_17(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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::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_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FixedRateBond__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FixedRateBond__SWIG_16(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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::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_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_FixedRateBond__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_FixedRateBond__SWIG_15(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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::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_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_FixedRateBond__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FixedRateBond__SWIG_14(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_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::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_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FixedRateBond__SWIG_30(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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::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_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) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FixedRateBond__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_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_Calendar, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FixedRateBond__SWIG_13(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_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::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_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_FixedRateBond__SWIG_29(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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::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_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) {
                  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_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_FixedRateBond__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_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_Calendar, 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_FixedRateBond__SWIG_12(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_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::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_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_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_FixedRateBond__SWIG_28(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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::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_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) {
                  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_Calendar, SWIG_POINTER_NO_NULL | 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) {
                        return _wrap_new_FixedRateBond__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_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_Calendar, 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_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FixedRateBond__SWIG_11(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_FixedRateBond__SWIG_27(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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::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_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) {
                  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_Calendar, SWIG_POINTER_NO_NULL | 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_ConvertPtr(argv[10], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_FixedRateBond__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_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_Calendar, 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_Calendar, 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_FixedRateBond__SWIG_10(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_FixedRateBond__SWIG_26(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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::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_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) {
                  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_Calendar, SWIG_POINTER_NO_NULL | 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_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_FixedRateBond__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(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_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_Calendar, 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_Calendar, 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_FixedRateBond__SWIG_9(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_FixedRateBond__SWIG_25(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      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::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_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) {
                  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_Calendar, SWIG_POINTER_NO_NULL | 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_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_FixedRateBond__SWIG_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_FixedRateBond__SWIG_24(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_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_FixedRateBond__SWIG_23(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_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) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_FixedRateBond__SWIG_22(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_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) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_new_FixedRateBond__SWIG_21(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_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) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_FixedRateBond__SWIG_20(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_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) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_new_FixedRateBond__SWIG_19(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    {
      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_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::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_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_AsVal_int(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_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) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_int(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_bool(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_new_FixedRateBond__SWIG_18(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FixedRateBond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date,Calendar const &,Period const &,Calendar const &,BusinessDayConvention,bool)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date,Calendar const &,Period const &,Calendar const &,BusinessDayConvention)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date,Calendar const &,Period const &,Calendar const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date,Calendar const &,Period const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date,Calendar const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &,BusinessDayConvention,bool)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &,BusinessDayConvention)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real,Date const &,Calendar const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real,Date const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention,Real)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &,BusinessDayConvention)\n"
    "    FixedRateBond::FixedRateBond(Integer,Real,Schedule const &,std::vector< InterestRate,std::allocator< InterestRate > > const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule,bool,Calendar const &,Period const &,Calendar const &,BusinessDayConvention const,bool)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule,bool,Calendar const &,Period const &,Calendar const &,BusinessDayConvention const)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule,bool,Calendar const &,Period const &,Calendar const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule,bool,Calendar const &,Period const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule,bool,Calendar const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule,bool)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &,DateGeneration::Rule)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &,Date const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real,Date const &)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention,Real)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,BusinessDayConvention)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention)\n"
    "    FixedRateBond::FixedRateBond(Integer,Calendar const &,Real,Date const &,Date const &,Period const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FixedRateBond_from_rates(PyObject *SWIGUNUSEDPARM(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 
  };
  ext::shared_ptr< FixedRateBond > result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOO:FixedRateBond_from_rates", 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 '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "8"" of type '" "Date""'"); 
      }  
      if (!argp8) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "9"" of type '" "Calendar const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "10"" of type '" "Period const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', 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 '" "FixedRateBond_from_rates" "', argument " "13"" of type '" "bool""'");
    } 
    arg13 = static_cast< bool >(val13);
  }
  {
    try {
      result = FixedRateBond_from_rates(arg1,arg2,(Schedule const &)*arg3,(std::vector< double,std::allocator< double > > 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) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedRateBond_from_interest_rates(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  BusinessDayConvention arg5 = (BusinessDayConvention) Following ;
  Real arg6 = (Real) 100.0 ;
  Date const &arg7_defvalue = Date() ;
  Date *arg7 = (Date *) &arg7_defvalue ;
  Calendar const &arg8_defvalue = Calendar() ;
  Calendar *arg8 = (Calendar *) &arg8_defvalue ;
  Period const &arg9_defvalue = Period() ;
  Period *arg9 = (Period *) &arg9_defvalue ;
  Calendar const &arg10_defvalue = Calendar() ;
  Calendar *arg10 = (Calendar *) &arg10_defvalue ;
  BusinessDayConvention arg11 = (BusinessDayConvention) Unadjusted ;
  bool arg12 = (bool) false ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  bool 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 *)"settlementDays",  (char *)"faceAmount",  (char *)"schedule",  (char *)"coupons",  (char *)"paymentConvention",  (char *)"redemption",  (char *)"issueDate",  (char *)"paymentCalendar",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  ext::shared_ptr< FixedRateBond > result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOOOO:FixedRateBond_from_interest_rates", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FixedRateBond_from_interest_rates" "', 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 '" "FixedRateBond_from_interest_rates" "', 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 '" "FixedRateBond_from_interest_rates" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_interest_rates" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    std::vector< InterestRate,std::allocator< InterestRate > > *ptr = (std::vector< InterestRate,std::allocator< InterestRate > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedRateBond_from_interest_rates" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_interest_rates" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FixedRateBond_from_interest_rates" "', 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 '" "FixedRateBond_from_interest_rates" "', 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 '" "FixedRateBond_from_interest_rates" "', argument " "7"" of type '" "Date const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_interest_rates" "', argument " "7"" of type '" "Date const &""'"); 
    }
    arg7 = reinterpret_cast< Date * >(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 '" "FixedRateBond_from_interest_rates" "', argument " "8"" of type '" "Calendar const &""'"); 
    }
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_interest_rates" "', argument " "8"" of type '" "Calendar const &""'"); 
    }
    arg8 = reinterpret_cast< Calendar * >(argp8);
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "FixedRateBond_from_interest_rates" "', argument " "9"" of type '" "Period const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_interest_rates" "', argument " "9"" of type '" "Period const &""'"); 
    }
    arg9 = reinterpret_cast< Period * >(argp9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "FixedRateBond_from_interest_rates" "', argument " "10"" of type '" "Calendar const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_interest_rates" "', 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 '" "FixedRateBond_from_interest_rates" "', argument " "11"" of type '" "BusinessDayConvention""'");
    } 
    arg11 = static_cast< BusinessDayConvention >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "FixedRateBond_from_interest_rates" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  {
    try {
      result = FixedRateBond_from_interest_rates(arg1,arg2,(Schedule const &)*arg3,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4,arg5,arg6,(Date const &)*arg7,(Calendar const &)*arg8,(Period const &)*arg9,(Calendar 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<  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);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedRateBond_from_date_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 = (BusinessDayConvention) QuantLib::Following ;
  BusinessDayConvention arg10 = (BusinessDayConvention) QuantLib::Following ;
  Real arg11 = (Real) 100.0 ;
  Date const &arg12_defvalue = Date() ;
  Date *arg12 = (Date *) &arg12_defvalue ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  DateGeneration::Rule arg14 = (DateGeneration::Rule) QuantLib::DateGeneration::Backward ;
  bool arg15 = (bool) false ;
  Calendar const &arg16_defvalue = Calendar() ;
  Calendar *arg16 = (Calendar *) &arg16_defvalue ;
  Period const &arg17_defvalue = Period() ;
  Period *arg17 = (Period *) &arg17_defvalue ;
  Calendar const &arg18_defvalue = Calendar() ;
  Calendar *arg18 = (Calendar *) &arg18_defvalue ;
  BusinessDayConvention arg19 = (BusinessDayConvention) (BusinessDayConvention)Unadjusted ;
  bool arg20 = (bool) false ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int 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 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  bool val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"couponCalendar",  (char *)"faceAmount",  (char *)"startDate",  (char *)"maturityDate",  (char *)"tenor",  (char *)"coupons",  (char *)"accrualDayCounter",  (char *)"accrualConvention",  (char *)"paymentConvention",  (char *)"redemption",  (char *)"issueDate",  (char *)"stubDate",  (char *)"rule",  (char *)"endOfMonth",  (char *)"paymentCalendar",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  ext::shared_ptr< FixedRateBond > result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO|OOOOOOOOOOOO:FixedRateBond_from_date_info", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18, &obj19)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FixedRateBond_from_date_info" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedRateBond_from_date_info" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', 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 '" "FixedRateBond_from_date_info" "', 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 '" "FixedRateBond_from_date_info" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FixedRateBond_from_date_info" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FixedRateBond_from_date_info" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  {
    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 '" "FixedRateBond_from_date_info" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "FixedRateBond_from_date_info" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FixedRateBond_from_date_info" "', 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 '" "FixedRateBond_from_date_info" "', argument " "10"" of type '" "BusinessDayConvention""'");
    } 
    arg10 = static_cast< BusinessDayConvention >(val10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_double(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "FixedRateBond_from_date_info" "', argument " "11"" of type '" "Real""'");
    } 
    arg11 = static_cast< Real >(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 '" "FixedRateBond_from_date_info" "', argument " "12"" of type '" "Date const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "12"" of type '" "Date const &""'"); 
    }
    arg12 = reinterpret_cast< Date * >(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 '" "FixedRateBond_from_date_info" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "FixedRateBond_from_date_info" "', argument " "14"" of type '" "DateGeneration::Rule""'");
    } 
    arg14 = static_cast< DateGeneration::Rule >(val14);
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_bool(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "FixedRateBond_from_date_info" "', 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 '" "FixedRateBond_from_date_info" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    if (!argp16) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    arg16 = reinterpret_cast< Calendar * >(argp16);
  }
  if (obj16) {
    res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "FixedRateBond_from_date_info" "', argument " "17"" of type '" "Period const &""'"); 
    }
    if (!argp17) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "17"" of type '" "Period const &""'"); 
    }
    arg17 = reinterpret_cast< Period * >(argp17);
  }
  if (obj17) {
    res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "FixedRateBond_from_date_info" "', argument " "18"" of type '" "Calendar const &""'"); 
    }
    if (!argp18) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateBond_from_date_info" "', argument " "18"" of type '" "Calendar const &""'"); 
    }
    arg18 = reinterpret_cast< Calendar * >(argp18);
  }
  if (obj18) {
    ecode19 = SWIG_AsVal_int(obj18, &val19);
    if (!SWIG_IsOK(ecode19)) {
      SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "FixedRateBond_from_date_info" "', argument " "19"" of type '" "BusinessDayConvention""'");
    } 
    arg19 = static_cast< BusinessDayConvention >(val19);
  }
  if (obj19) {
    ecode20 = SWIG_AsVal_bool(obj19, &val20);
    if (!SWIG_IsOK(ecode20)) {
      SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "FixedRateBond_from_date_info" "', argument " "20"" of type '" "bool""'");
    } 
    arg20 = static_cast< bool >(val20);
  }
  {
    try {
      result = FixedRateBond_from_date_info(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(std::vector< double,std::allocator< double > > const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,arg14,arg15,(Calendar const &)*arg16,(Period const &)*arg17,(Calendar const &)*arg18,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<  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);
  }
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedRateBond_frequency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedRateBond(PyObject *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  BusinessDayConvention arg10 ;
  bool arg11 ;
  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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &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);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  BusinessDayConvention arg10 ;
  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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    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_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;
    }
  }
  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_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);
  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_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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Date arg7 ;
  Period *arg8 = 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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    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_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;
    }
  }
  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_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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  Date arg7 ;
  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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    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_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;
    }
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  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 ;
  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 ;
  AmortizingFixedRateBond *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_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(swig_obj[1], &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(swig_obj[2], &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(swig_obj[3], &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(swig_obj[4], &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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date arg4 ;
  Period *arg5 = 0 ;
  Frequency *arg6 = 0 ;
  Real arg7 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  Date arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 ;
  Frequency temp6 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  AmortizingFixedRateBond *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_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AmortizingFixedRateBond" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "6"" of type '" "Frequency const &""'");
  } else {
    temp6 = static_cast< Frequency >(val6);
    arg6 = &temp6;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AmortizingFixedRateBond" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(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_AmortizingFixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(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_AmortizingFixedRateBond" "', argument " "10"" of type '" "Date""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "10"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(Calendar const &)*arg2,arg3,arg4,(Period const &)*arg5,(Frequency const &)*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<  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);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date arg4 ;
  Period *arg5 = 0 ;
  Frequency *arg6 = 0 ;
  Real arg7 ;
  DayCounter *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 ;
  Frequency temp6 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  AmortizingFixedRateBond *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_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AmortizingFixedRateBond" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "6"" of type '" "Frequency const &""'");
  } else {
    temp6 = static_cast< Frequency >(val6);
    arg6 = &temp6;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AmortizingFixedRateBond" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(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_AmortizingFixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(Calendar const &)*arg2,arg3,arg4,(Period const &)*arg5,(Frequency const &)*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<  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);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date arg4 ;
  Period *arg5 = 0 ;
  Frequency *arg6 = 0 ;
  Real arg7 ;
  DayCounter *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 ;
  Frequency temp6 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  AmortizingFixedRateBond *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_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AmortizingFixedRateBond" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', 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_AmortizingFixedRateBond" "', argument " "6"" of type '" "Frequency const &""'");
  } else {
    temp6 = static_cast< Frequency >(val6);
    arg6 = &temp6;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AmortizingFixedRateBond" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(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_AmortizingFixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(Calendar const &)*arg2,arg3,arg4,(Period const &)*arg5,(Frequency const &)*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<  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);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AmortizingFixedRateBond", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v;
    {
      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::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_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_AmortizingFixedRateBond__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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::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_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_AmortizingFixedRateBond__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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::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_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_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_AmortizingFixedRateBond__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_Date, 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_double(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_AmortizingFixedRateBond__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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::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_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_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_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_AmortizingFixedRateBond__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_Date, 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_double(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_AmortizingFixedRateBond__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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::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_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_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_Period, SWIG_POINTER_NO_NULL | 0);
                  _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_AmortizingFixedRateBond__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_Date, 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_double(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_AmortizingFixedRateBond__SWIG_7(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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::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_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_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_Period, SWIG_POINTER_NO_NULL | 0);
                  _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_AmortizingFixedRateBond__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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::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_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_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_Period, SWIG_POINTER_NO_NULL | 0);
                  _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_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_AmortizingFixedRateBond__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AmortizingFixedRateBond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Date,Period const &,Calendar const &,BusinessDayConvention const,bool)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Date,Period const &,Calendar const &,BusinessDayConvention const)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Date,Period const &,Calendar const &)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Date,Period const &)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Date)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,Calendar const &,Real,Date,Period const &,Frequency const &,Real,DayCounter const &,BusinessDayConvention,Date)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,Calendar const &,Real,Date,Period const &,Frequency const &,Real,DayCounter const &,BusinessDayConvention)\n"
    "    AmortizingFixedRateBond::AmortizingFixedRateBond(Integer,Calendar const &,Real,Date,Period const &,Frequency const &,Real,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AmortizingFixedRateBond_frequency(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AmortizingFixedRateBond(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 ;
  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 *)"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",  NULL 
  };
  AmortizingFloatingRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOOOOOO:new_AmortizingFloatingRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "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);
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
  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_AmortizingFloatingRateBond(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_DiscountingBondEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CallableBond_callability(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  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 ;
  double val2 ;
  int ecode2 = 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));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_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 '" "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(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_isTradable__SWIG_0(PyObject *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualStartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualEndDate__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,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_BondFunctions_bondYield__SWIG_1(PyObject *SWIGUNUSEDPARM(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,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_BondFunctions_bondYield__SWIG_2(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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,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_BondFunctions_zSpread__SWIG_1(PyObject *SWIGUNUSEDPARM(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,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_zSpread__SWIG_2(PyObject *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldBrent__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldBrent__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBrent__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldBisection__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldBisection__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBisection__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldFalsePosition__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldFalsePosition__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldFalsePosition__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldRidder__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldRidder__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldRidder__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldSecant__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldSecant__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldSecant__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldNewton__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldNewton__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewton__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldNewtonSafe__SWIG_1(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond const &)*arg2,arg3,(DayCounter 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_BondFunctions_yieldNewtonSafe__SWIG_2(PyObject *SWIGUNUSEDPARM(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(arg1,(Bond 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));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewtonSafe__SWIG_3(PyObject *SWIGUNUSEDPARM(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(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_CapFloor_impliedVolatility__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_type(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_delete_Dividend(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_ConvertibleZeroCouponBond__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  DayCounter *arg8 = 0 ;
  Schedule *arg9 = 0 ;
  Real arg10 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  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 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  ConvertibleZeroCouponBond *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_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< 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 '" "new_ConvertibleZeroCouponBond" "', 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 '" "new_ConvertibleZeroCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleZeroCouponBond" "', 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 '" "new_ConvertibleZeroCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleZeroCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(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_ConvertibleZeroCouponBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "9"" of type '" "Schedule const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "9"" of type '" "Schedule const &""'"); 
  }
  arg9 = reinterpret_cast< Schedule * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (ConvertibleZeroCouponBond *)new ConvertibleZeroCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(DayCounter const &)*arg8,(Schedule 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<  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;
  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_ConvertibleZeroCouponBond__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  DayCounter *arg8 = 0 ;
  Schedule *arg9 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  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 = 0 ;
  int res9 = 0 ;
  ConvertibleZeroCouponBond *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_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< 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 '" "new_ConvertibleZeroCouponBond" "', 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 '" "new_ConvertibleZeroCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleZeroCouponBond" "', 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 '" "new_ConvertibleZeroCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleZeroCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(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_ConvertibleZeroCouponBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "9"" of type '" "Schedule const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "9"" of type '" "Schedule const &""'"); 
  }
  arg9 = reinterpret_cast< Schedule * >(argp9);
  {
    try {
      result = (ConvertibleZeroCouponBond *)new ConvertibleZeroCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(DayCounter const &)*arg8,(Schedule 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<  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;
  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_ConvertibleZeroCouponBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvertibleZeroCouponBond", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_Schedule, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_ConvertibleZeroCouponBond__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_Schedule, 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_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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > const &,Date const &,Integer,DayCounter const &,Schedule const &,Real)\n"
    "    ConvertibleZeroCouponBond::ConvertibleZeroCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > const &,Date const &,Integer,DayCounter const &,Schedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvertibleZeroCouponBond(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate,std::allocator< Rate > > *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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  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 ;
  ConvertibleFixedCouponBond *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_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< 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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > 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_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< Rate,std::allocator< Rate > > 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate,std::allocator< Rate > > *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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  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 ;
  ConvertibleFixedCouponBond *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_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< 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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > 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_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "14"" of type '" "BusinessDayConvention""'");
  } 
  arg14 = static_cast< BusinessDayConvention >(val14);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< Rate,std::allocator< Rate > > 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate,std::allocator< Rate > > *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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  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 ;
  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< 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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > 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_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  arg13 = reinterpret_cast< Calendar * >(argp13);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< Rate,std::allocator< Rate > > 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate,std::allocator< Rate > > *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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  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 ;
  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< 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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > 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_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  arg12 = reinterpret_cast< Period * >(argp12);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< Rate,std::allocator< Rate > > 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate,std::allocator< Rate > > *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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  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 ;
  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< 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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > 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_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< Rate,std::allocator< Rate > > 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Rate,std::allocator< Rate > > *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 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 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< 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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFixedCouponBond" "', 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 '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > 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_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', 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_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(std::vector< Rate,std::allocator< Rate > > 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvertibleFixedCouponBond", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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::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_ConvertibleFixedCouponBond__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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::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_ConvertibleFixedCouponBond__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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::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_ConvertibleFixedCouponBond__SWIG_3(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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::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_ConvertibleFixedCouponBond__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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::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_ConvertibleFixedCouponBond__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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::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_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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvertibleFixedCouponBond(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  Real arg13 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  bool arg17 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) 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< 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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  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);
  {
    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_ConvertibleFloatingRateBond" "', 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;
    }
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "Integer""'");
  } 
  arg9 = static_cast< Integer >(val9);
  {
    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_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', 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_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  arg12 = reinterpret_cast< Schedule * >(argp12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  arg14 = reinterpret_cast< Period * >(argp14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
  }
  arg15 = reinterpret_cast< Calendar * >(argp15);
  ecode16 = SWIG_AsVal_int(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "16"" of type '" "BusinessDayConvention""'");
  } 
  arg16 = static_cast< BusinessDayConvention >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,(Schedule const &)*arg12,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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  Real arg13 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) 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< 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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  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);
  {
    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_ConvertibleFloatingRateBond" "', 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;
    }
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "Integer""'");
  } 
  arg9 = static_cast< Integer >(val9);
  {
    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_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', 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_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  arg12 = reinterpret_cast< Schedule * >(argp12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  arg14 = reinterpret_cast< Period * >(argp14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
  }
  arg15 = reinterpret_cast< Calendar * >(argp15);
  ecode16 = SWIG_AsVal_int(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "16"" of type '" "BusinessDayConvention""'");
  } 
  arg16 = static_cast< BusinessDayConvention >(val16);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,(Schedule const &)*arg12,arg13,(Period const &)*arg14,(Calendar 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  Real arg13 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 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< 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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  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);
  {
    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_ConvertibleFloatingRateBond" "', 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;
    }
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "Integer""'");
  } 
  arg9 = static_cast< Integer >(val9);
  {
    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_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', 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_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  arg12 = reinterpret_cast< Schedule * >(argp12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  arg14 = reinterpret_cast< Period * >(argp14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
  }
  arg15 = reinterpret_cast< Calendar * >(argp15);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,(Schedule const &)*arg12,arg13,(Period const &)*arg14,(Calendar 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  Real arg13 ;
  Period *arg14 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 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< 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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  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);
  {
    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_ConvertibleFloatingRateBond" "', 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;
    }
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "Integer""'");
  } 
  arg9 = static_cast< Integer >(val9);
  {
    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_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', 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_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  arg12 = reinterpret_cast< Schedule * >(argp12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
  }
  arg14 = reinterpret_cast< Period * >(argp14);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,(Schedule const &)*arg12,arg13,(Period 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  Real arg13 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  double val13 ;
  int ecode13 = 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< 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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  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);
  {
    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_ConvertibleFloatingRateBond" "', 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;
    }
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "Integer""'");
  } 
  arg9 = static_cast< Integer >(val9);
  {
    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_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', 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_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  arg12 = reinterpret_cast< Schedule * >(argp12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,(Schedule 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<  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(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Date *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Integer arg9 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  Schedule *arg12 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 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< 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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_ConvertibleFloatingRateBond" "', 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 '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  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_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(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_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  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);
  {
    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_ConvertibleFloatingRateBond" "', 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;
    }
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "Integer""'");
  } 
  arg9 = static_cast< Integer >(val9);
  {
    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_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', 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_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Schedule const &""'"); 
  }
  arg12 = reinterpret_cast< Schedule * >(argp12);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4,(Handle< Quote > const &)*arg5,(Date const &)*arg6,arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,(Schedule 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(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[18] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvertibleFloatingRateBond", 0, 17, argv))) SWIG_fail;
  --argc;
  if (argc == 12) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _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_ConvertPtr(argv[11], 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 == 13) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _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_ConvertPtr(argv[11], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ConvertibleFloatingRateBond__SWIG_4(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _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_ConvertPtr(argv[11], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 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_Period, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_ConvertibleFloatingRateBond__SWIG_3(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _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_ConvertPtr(argv[11], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 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_Period, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 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 == 16) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _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_ConvertPtr(argv[11], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 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_Period, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ConvertibleFloatingRateBond__SWIG_1(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _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) {
            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_Date, 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_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _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_ConvertPtr(argv[11], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 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_Period, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(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_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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Handle< Quote > 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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< CoxRossRubinstein > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialCRRConvertibleEngine", 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_BinomialCRRConvertibleEngine" "', 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_BinomialCRRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< CoxRossRubinstein > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialCRRConvertibleEngine(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< JarrowRudd > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialJRConvertibleEngine", 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_BinomialJRConvertibleEngine" "', 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_BinomialJRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< JarrowRudd > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialJRConvertibleEngine(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialEQPConvertibleEngine", 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_BinomialEQPConvertibleEngine" "', 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_BinomialEQPConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialEQPConvertibleEngine(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< Trigeorgis > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialTrigeorgisConvertibleEngine", 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_BinomialTrigeorgisConvertibleEngine" "', 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_BinomialTrigeorgisConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< Trigeorgis > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialTrigeorgisConvertibleEngine(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< Tian > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialTianConvertibleEngine", 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_BinomialTianConvertibleEngine" "', 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_BinomialTianConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< Tian > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialTianConvertibleEngine(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< LeisenReimer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialLRConvertibleEngine", 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_BinomialLRConvertibleEngine" "', 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_BinomialLRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< LeisenReimer > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialLRConvertibleEngine(PyObject *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(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] ;
  BinomialConvertibleEngine< Joshi4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialJ4ConvertibleEngine", 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_BinomialJ4ConvertibleEngine" "', 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_BinomialJ4ConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialConvertibleEngine< Joshi4 > *)new BinomialConvertibleEngine< 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<  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_delete_BinomialJ4ConvertibleEngine(PyObject *SWIGUNUSEDPARM(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_new_Futures(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_OvernightIndexFuture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexFuture *arg1 = (OvernightIndexFuture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OvernightIndexFuture, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndexFuture" "', argument " "1"" of type '" "OvernightIndexFuture *""'"); 
  }
  arg1 = reinterpret_cast< OvernightIndexFuture * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_OvernightIndexFuture, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Pillar(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_earliestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_latestRelevantDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_pillarDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_impliedQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(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;
    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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FraRateHelper(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    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;
    {
      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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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_7(PyObject *SWIGUNUSEDPARM(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_8(PyObject *SWIGUNUSEDPARM(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_9(PyObject *SWIGUNUSEDPARM(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_10(PyObject *SWIGUNUSEDPARM(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_11(PyObject *SWIGUNUSEDPARM(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_12(PyObject *SWIGUNUSEDPARM(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_13(PyObject *SWIGUNUSEDPARM(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_14(PyObject *SWIGUNUSEDPARM(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_15(PyObject *SWIGUNUSEDPARM(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_16(PyObject *SWIGUNUSEDPARM(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_17(PyObject *SWIGUNUSEDPARM(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_18(PyObject *SWIGUNUSEDPARM(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_19(PyObject *SWIGUNUSEDPARM(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_20(PyObject *SWIGUNUSEDPARM(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_21(PyObject *SWIGUNUSEDPARM(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_22(PyObject *SWIGUNUSEDPARM(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_23(PyObject *SWIGUNUSEDPARM(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_24(PyObject *SWIGUNUSEDPARM(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_25(PyObject *SWIGUNUSEDPARM(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[14] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwapRateHelper", 0, 13, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    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_19(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      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_25(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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_18(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      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_24(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_17(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_23(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_16(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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_22(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_15(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_21(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_14(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_20(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_13(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_12(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    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_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_11(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    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_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_10(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    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_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_9(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    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_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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_8(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    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_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      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_7(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)\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)\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)\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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond > tempshared2 ;
  bool 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_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BondHelper" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(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 *SWIGUNUSEDPARM(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;
    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;
    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_bool(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 &,bool)\n"
    "    BondHelper::BondHelper(Handle< Quote > const &,ext::shared_ptr< Bond > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelper_bond(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  bool 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 ;
  bool 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_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBondHelper" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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_bool(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,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,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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >() ;
  Handle< YieldTermStructure > *arg5 = (Handle< YieldTermStructure > *) &arg5_defvalue ;
  bool arg6 = (bool) false ;
  Natural arg7 = (Natural) 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() ;
  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 ;
  unsigned 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 ;
  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 *)"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",  NULL 
  };
  OISRateHelper *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOOOOOO:new_OISRateHelper", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) 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_unsigned_SS_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OISRateHelper" "', argument " "7"" of type '" "Natural""'");
    } 
    arg7 = static_cast< Natural >(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;
      }
    }
  }
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *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 ;
  DatedOISRateHelper *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_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(swig_obj[1], &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(swig_obj[2], &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(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_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;
    }
  }
  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_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);
  {
    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);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_DatedOISRateHelper__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *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 ;
  DatedOISRateHelper *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_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(swig_obj[1], &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(swig_obj[2], &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(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_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;
    }
  }
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > 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<  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_new_DatedOISRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatedOISRateHelper", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    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_OvernightIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_DatedOISRateHelper__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_OvernightIndex_t, 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_DatedOISRateHelper__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatedOISRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DatedOISRateHelper::DatedOISRateHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< OvernightIndex > const &,Handle< YieldTermStructure > const &)\n"
    "    DatedOISRateHelper::DatedOISRateHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatedOISRateHelper(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  OvernightIndexFuture::NettingType 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 '" "OvernightIndexFuture::NettingType""'");
  } 
  arg6 = static_cast< OvernightIndexFuture::NettingType >(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 &,OvernightIndexFuture::NettingType)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Handle< Quote > *arg6 = 0 ;
  OvernightIndexFuture::NettingType arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SofrFutureRateHelper *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_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);
  {
    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_SofrFutureRateHelper" "', 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_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SofrFutureRateHelper" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SofrFutureRateHelper" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SofrFutureRateHelper" "', argument " "7"" of type '" "OvernightIndexFuture::NettingType""'");
  } 
  arg7 = static_cast< OvernightIndexFuture::NettingType >(val7);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,(Handle< Quote > 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<  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Handle< Quote > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SofrFutureRateHelper *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_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);
  {
    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_SofrFutureRateHelper" "', 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_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SofrFutureRateHelper" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SofrFutureRateHelper" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*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<  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< OvernightIndex > *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 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  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);
  {
    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_SofrFutureRateHelper" "', 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 = (SofrFutureRateHelper *)new SofrFutureRateHelper((Handle< Quote > const &)*arg1,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<  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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  OvernightIndexFuture::NettingType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SofrFutureRateHelper *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_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);
  {
    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_SofrFutureRateHelper" "', 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_SofrFutureRateHelper" "', 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_SofrFutureRateHelper" "', argument " "7"" of type '" "OvernightIndexFuture::NettingType""'");
  } 
  arg7 = static_cast< OvernightIndexFuture::NettingType >(val7);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper(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<  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_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  SofrFutureRateHelper *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_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);
  {
    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_SofrFutureRateHelper" "', 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_SofrFutureRateHelper" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper(arg1,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<  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_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  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);
  {
    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_SofrFutureRateHelper" "', 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 = (SofrFutureRateHelper *)new SofrFutureRateHelper(arg1,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<  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[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SofrFutureRateHelper", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v;
    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_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SofrFutureRateHelper__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SofrFutureRateHelper__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_ext__shared_ptrT_OvernightIndex_t, 0);
            _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_SofrFutureRateHelper__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_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_SofrFutureRateHelper__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_ext__shared_ptrT_OvernightIndex_t, 0);
            _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_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SofrFutureRateHelper__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_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_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SofrFutureRateHelper__SWIG_3(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,ext::shared_ptr< OvernightIndex > const &,Handle< Quote > const &,OvernightIndexFuture::NettingType)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Handle< Quote > const &,Month,Year,Frequency,ext::shared_ptr< OvernightIndex > const &,Handle< Quote > const &)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Handle< Quote > const &,Month,Year,Frequency,ext::shared_ptr< OvernightIndex > const &)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Real,Month,Year,Frequency,ext::shared_ptr< OvernightIndex > const &,Real,OvernightIndexFuture::NettingType)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Real,Month,Year,Frequency,ext::shared_ptr< OvernightIndex > const &,Real)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Real,Month,Year,Frequency,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SofrFutureRateHelper(PyObject *SWIGUNUSEDPARM(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_RateHelperVector_iterator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_new_Discount(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  doubleOrNull arg1 = (doubleOrNull) Null< double >() ;
  doubleOrNull arg2 = (doubleOrNull) Null< double >() ;
  doubleOrNull arg3 = (doubleOrNull) Null< double >() ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"accuracy",  (char *)"minValue",  (char *)"maxValue",  NULL 
  };
  _IterativeBootstrap *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:new_IterativeBootstrap", kwnames, &obj0, &obj1, &obj2)) 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");
    }
  }
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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__IterativeBootstrap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IterativeBootstrap(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  BackwardFlat *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseFlatForward *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  BackwardFlat *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  BackwardFlat *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseFlatForward *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseFlatForward" "', argument " "8"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "8"" of type '" "BackwardFlat const &""'"); 
  }
  arg8 = reinterpret_cast< BackwardFlat * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseFlatForward" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_6(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,arg7,(BackwardFlat const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  BackwardFlat *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseFlatForward" "', argument " "8"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "8"" of type '" "BackwardFlat const &""'"); 
  }
  arg8 = reinterpret_cast< BackwardFlat * >(argp8);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_6(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,arg7,(BackwardFlat 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseFlatForward", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseFlatForward__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseFlatForward__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseFlatForward__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseFlatForward__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseFlatForward(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  LogLinear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLogLinearDiscount *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  LogLinear *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  LogLinear *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseLogLinearDiscount *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "8"" of type '" "LogLinear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "8"" of type '" "LogLinear const &""'"); 
  }
  arg8 = reinterpret_cast< LogLinear * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_6(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,arg7,(LogLinear const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  LogLinear *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "8"" of type '" "LogLinear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "8"" of type '" "LogLinear const &""'"); 
  }
  arg8 = reinterpret_cast< LogLinear * >(argp8);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_6(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,arg7,(LogLinear 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLogLinearDiscount", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseLogLinearDiscount__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseLogLinearDiscount__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLogLinearDiscount__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseLogLinearDiscount__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseLogLinearDiscount(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Linear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLinearForward *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Linear *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Linear *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseLinearForward *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  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_PiecewiseLinearForward" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  arg8 = reinterpret_cast< Linear * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseLinearForward" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_6(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,arg7,(Linear const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Linear *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  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_PiecewiseLinearForward" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  arg8 = reinterpret_cast< Linear * >(argp8);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_6(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,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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLinearForward", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseLinearForward__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseLinearForward__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _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_PiecewiseLinearForward__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _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) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseLinearForward__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseLinearForward(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Linear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLinearZero *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Linear *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Linear *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseLinearZero *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  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_PiecewiseLinearZero" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  arg8 = reinterpret_cast< Linear * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseLinearZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_6(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,arg7,(Linear const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Linear *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  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_PiecewiseLinearZero" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  arg8 = reinterpret_cast< Linear * >(argp8);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_6(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,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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLinearZero", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseLinearZero__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseLinearZero__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _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_PiecewiseLinearZero__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _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) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseLinearZero__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseLinearZero(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Cubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseCubicZero *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Cubic *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Cubic *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseCubicZero *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseCubicZero" "', argument " "8"" of type '" "Cubic const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "8"" of type '" "Cubic const &""'"); 
  }
  arg8 = reinterpret_cast< Cubic * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseCubicZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_6(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,arg7,(Cubic const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Cubic *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseCubicZero" "', argument " "8"" of type '" "Cubic const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "8"" of type '" "Cubic const &""'"); 
  }
  arg8 = reinterpret_cast< Cubic * >(argp8);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_6(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,arg7,(Cubic 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseCubicZero", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseCubicZero__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseCubicZero__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseCubicZero__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseCubicZero__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseCubicZero(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  MonotonicLogCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLogCubicDiscount *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  MonotonicLogCubic *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  MonotonicLogCubic *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseLogCubicDiscount *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "8"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "8"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg8 = reinterpret_cast< MonotonicLogCubic * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_6(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,arg7,(MonotonicLogCubic const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  MonotonicLogCubic *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "8"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "8"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg8 = reinterpret_cast< MonotonicLogCubic * >(argp8);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_6(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,arg7,(MonotonicLogCubic 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLogCubicDiscount", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseLogCubicDiscount__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseLogCubicDiscount__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLogCubicDiscount__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseLogCubicDiscount__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseLogCubicDiscount(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  SplineCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseSplineCubicDiscount *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  SplineCubic *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  SplineCubic *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseSplineCubicDiscount *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "8"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "8"" of type '" "SplineCubic const &""'"); 
  }
  arg8 = reinterpret_cast< SplineCubic * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_6(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,arg7,(SplineCubic const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  SplineCubic *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "8"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "8"" of type '" "SplineCubic const &""'"); 
  }
  arg8 = reinterpret_cast< SplineCubic * >(argp8);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_6(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,arg7,(SplineCubic 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseSplineCubicDiscount", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseSplineCubicDiscount(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Kruger *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseKrugerZero *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  Kruger *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Kruger *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseKrugerZero *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseKrugerZero" "', argument " "8"" of type '" "Kruger const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "8"" of type '" "Kruger const &""'"); 
  }
  arg8 = reinterpret_cast< Kruger * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseKrugerZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_6(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,arg7,(Kruger const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  Kruger *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseKrugerZero" "', argument " "8"" of type '" "Kruger const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "8"" of type '" "Kruger const &""'"); 
  }
  arg8 = reinterpret_cast< Kruger * >(argp8);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_6(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,arg7,(Kruger 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseKrugerZero", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseKrugerZero__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseKrugerZero__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseKrugerZero__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseKrugerZero__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseKrugerZero(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  KrugerLog *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseKrugerLogDiscount *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  KrugerLog *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  KrugerLog *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseKrugerLogDiscount *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "8"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "8"" of type '" "KrugerLog const &""'"); 
  }
  arg8 = reinterpret_cast< KrugerLog * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_6(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,arg7,(KrugerLog const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  KrugerLog *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "8"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "8"" of type '" "KrugerLog const &""'"); 
  }
  arg8 = reinterpret_cast< KrugerLog * >(argp8);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_6(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,arg7,(KrugerLog 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseKrugerLogDiscount", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseKrugerLogDiscount(PyObject *SWIGUNUSEDPARM(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_PiecewiseConvexMonotoneZero__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  ConvexMonotone *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 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 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseConvexMonotoneZero *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_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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  ConvexMonotone *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 ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  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_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,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(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 *SWIGUNUSEDPARM(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 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  double val6 ;
  int ecode6 = 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;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    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,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  ConvexMonotone *arg8 = 0 ;
  _IterativeBootstrap *arg9 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseConvexMonotoneZero *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_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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "8"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "8"" of type '" "ConvexMonotone const &""'"); 
  }
  arg8 = reinterpret_cast< ConvexMonotone * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "9"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg9 = reinterpret_cast< _IterativeBootstrap * >(argp9);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_6(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,arg7,(ConvexMonotone const &)*arg8,(_IterativeBootstrap 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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  ConvexMonotone *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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "8"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "8"" of type '" "ConvexMonotone const &""'"); 
  }
  arg8 = reinterpret_cast< ConvexMonotone * >(argp8);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_6(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,arg7,(ConvexMonotone 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_8(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg7 ;
  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 ;
  double val7 ;
  int ecode7 = 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;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_6(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,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_9(PyObject *SWIGUNUSEDPARM(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_6(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_10(PyObject *SWIGUNUSEDPARM(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_6(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_11(PyObject *SWIGUNUSEDPARM(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_6(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_12(PyObject *SWIGUNUSEDPARM(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_12((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_13(PyObject *SWIGUNUSEDPARM(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_13(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[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseConvexMonotoneZero", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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;
    {
      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_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    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_AsVal_double(argv[5], NULL);
                _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_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_6(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 &,Real,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 &,Real,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 &,Real)\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 &,Real,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 &,Real,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 &,Real)\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 &)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_PiecewiseConvexMonotoneZero(PyObject *SWIGUNUSEDPARM(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_GlobalBootstrap__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      _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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_latestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_earliestDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_maturityDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_latestRelevantDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_pillarDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_impliedQuote(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpreadCdsHelper", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v;
    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_2(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    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_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    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_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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_3(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)\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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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_7(PyObject *SWIGUNUSEDPARM(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[15] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UpfrontCdsHelper", 0, 14, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v;
    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_3(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_7(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    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_2(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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_6(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    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_1(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      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_5(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    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_0(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      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_4(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)\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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  Real arg4 ;
  BackwardFlat *arg5 = 0 ;
  _IterativeBootstrap *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseFlatHazardRate *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_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);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  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_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg2,(DayCounter const &)*arg3,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(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg4 ;
  BackwardFlat *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 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);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  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_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg2,(DayCounter const &)*arg3,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(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_2(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 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);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    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,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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 ;
  Real arg5 ;
  BackwardFlat *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseFlatHazardRate *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_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);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  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_PiecewiseFlatHazardRate" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', 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_PiecewiseFlatHazardRate" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_4(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3,(DayCounter const &)*arg4,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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg5 ;
  BackwardFlat *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 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);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  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_PiecewiseFlatHazardRate" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  arg6 = reinterpret_cast< BackwardFlat * >(argp6);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_4(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3,(DayCounter const &)*arg4,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<  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 *SWIGUNUSEDPARM(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 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 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);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_4(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > 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<  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_7(PyObject *SWIGUNUSEDPARM(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_4(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_8(PyObject *SWIGUNUSEDPARM(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_8((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_9(PyObject *SWIGUNUSEDPARM(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_9(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[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseFlatHazardRate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    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_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_PiecewiseFlatHazardRate__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      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_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_AsVal_double(argv[3], NULL);
            _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_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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_9(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PiecewiseFlatHazardRate__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_AsVal_double(argv[3], NULL);
            _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_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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_AsVal_double(argv[4], NULL);
              _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_PiecewiseFlatHazardRate__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_AsVal_double(argv[4], NULL);
              _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_PiecewiseFlatHazardRate__SWIG_4(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 &,Real,BackwardFlat const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Date const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,Real,BackwardFlat const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Date const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,Real)\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 &,Real,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 &,Real,BackwardFlat const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Integer,Calendar const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,Real)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Protection(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_1(PyObject *SWIGUNUSEDPARM(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_2(PyObject *SWIGUNUSEDPARM(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_3(PyObject *SWIGUNUSEDPARM(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_4(PyObject *SWIGUNUSEDPARM(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_5(PyObject *SWIGUNUSEDPARM(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_6(PyObject *SWIGUNUSEDPARM(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_7(PyObject *SWIGUNUSEDPARM(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_8(PyObject *SWIGUNUSEDPARM(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_9(PyObject *SWIGUNUSEDPARM(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_10(PyObject *SWIGUNUSEDPARM(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_11(PyObject *SWIGUNUSEDPARM(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[15] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CreditDefaultSwap", 0, 14, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v;
    {
      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_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_11(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      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_10(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_9(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      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_8(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      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_7(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      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_6(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      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_5(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      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_4(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 &)\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)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_fairSpread(PyObject *SWIGUNUSEDPARM(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_fairUpfront(PyObject *SWIGUNUSEDPARM(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_couponLegBPS(PyObject *SWIGUNUSEDPARM(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_couponLegNPV(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_upfrontBPS(PyObject *SWIGUNUSEDPARM(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_upfrontNPV(PyObject *SWIGUNUSEDPARM(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_impliedHazardRate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject *swig_obj[4] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CreditDefaultSwap_conventionalSpread", 4, 4, swig_obj)) 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_coupons(PyObject *SWIGUNUSEDPARM(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_delete_CreditDefaultSwap(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCdsOptionEngine_volatility(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< Quote >& >(result))), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackCdsOptionEngine(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_NormalDistribution__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Money& >(result))), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money___pos__(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Money& >(result))), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_chain(PyObject *SWIGUNUSEDPARM(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(static_cast< const ExchangeRate& >(result))), SWIGTYPE_p_ExchangeRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExchangeRate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const ExchangeRate& >(result))), SWIGTYPE_p_ExchangeRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_lookup__SWIG_1(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_setEvaluationDate(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject *swig_obj[3] ;
  FdmLinearOpIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmLinearOpIterator", 3, 3, swig_obj)) 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((std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > 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_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_FdmLinearOpIterator_coordinates(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const FdmLinearOpIterator& >(result))), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_end(PyObject *SWIGUNUSEDPARM(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(static_cast< const FdmLinearOpIterator& >(result))), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_size(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const FdmLinearOpIterator& >(result))), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOpLayout(PyObject *SWIGUNUSEDPARM(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_delete_FdmMesher(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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_dplus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesherComposite const > tempshared1 ;
  ext::shared_ptr< FdmMesherComposite 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, "FdmMesherComposite_dplus", 3, 3, swig_obj)) SWIG_fail;
  {
    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_dplus" "', 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));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmMesherComposite_dplus" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmMesherComposite_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 '" "FdmMesherComposite_dplus" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((FdmMesherComposite 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_FdmMesherComposite_dminus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesherComposite const > tempshared1 ;
  ext::shared_ptr< FdmMesherComposite 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, "FdmMesherComposite_dminus", 3, 3, swig_obj)) SWIG_fail;
  {
    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_dminus" "', 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));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmMesherComposite_dminus" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmMesherComposite_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 '" "FdmMesherComposite_dminus" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((FdmMesherComposite 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_FdmMesherComposite_location(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesherComposite const > tempshared1 ;
  ext::shared_ptr< FdmMesherComposite 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, "FdmMesherComposite_location", 3, 3, swig_obj)) SWIG_fail;
  {
    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_location" "', 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));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmMesherComposite_location" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmMesherComposite_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 '" "FdmMesherComposite_location" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((FdmMesherComposite 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_FdmMesherComposite_locations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesherComposite const > tempshared1 ;
  ext::shared_ptr< FdmMesherComposite const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmMesherComposite_locations", 2, 2, swig_obj)) SWIG_fail;
  {
    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_locations" "', 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));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmMesherComposite_locations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = FdmMesherComposite_locations((FdmMesherComposite 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 Array(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmMesherComposite_layout(PyObject *SWIGUNUSEDPARM(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] ;
  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_FdmMesherComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesherComposite_layout" "', 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 {
      result = FdmMesherComposite_layout(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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_FdmMesherComposite_getFdm1dMeshers(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOp(PyObject *SWIGUNUSEDPARM(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_FdmLinearOpComposite_size(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_apply_direction(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_solve_splitting(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_preconditioner(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOpComposite(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_solve_splitting__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_solve_splitting__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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(static_cast< const 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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 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) {
            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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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((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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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((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 *SWIGUNUSEDPARM(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((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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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((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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 (extractArray(swig_obj[4],&temp5)) {
      arg5 = &temp5;
    } else {
      if (SWIG_ConvertPtr(swig_obj[4],(void **) &arg5,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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 *SWIGUNUSEDPARM(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,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 *SWIGUNUSEDPARM(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 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_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 '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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;
    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;
    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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(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,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;
    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;
    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__(PySliceObject *)\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 *SWIGUNUSEDPARM(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,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;
    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;
    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;
    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__(PySliceObject *,std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__setitem__(PySliceObject *)\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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(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,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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;
    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;
    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 *SWIGUNUSEDPARM(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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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,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 *SWIGUNUSEDPARM(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,arg2,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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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_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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FittingMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FittingMethod" "', argument " "1"" of type '" "FittingMethod *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 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_FittingMethod, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_size" "', argument " "1"" of type '" "FittingMethod const *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 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_FittingMethod, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_solution" "', argument " "1"" of type '" "FittingMethod const *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_numberOfIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 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_FittingMethod, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_numberOfIterations" "', argument " "1"" of type '" "FittingMethod const *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 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_FittingMethod, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_minimumCostValue" "', argument " "1"" of type '" "FittingMethod const *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 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_FittingMethod, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_constrainAtZero" "', argument " "1"" of type '" "FittingMethod const *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 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_FittingMethod, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_weights" "', argument " "1"" of type '" "FittingMethod const *""'"); 
  }
  arg1 = reinterpret_cast< FittingMethod * >(argp1);
  {
    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(static_cast< const 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_FittingMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Array temp8 ;
  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);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg5 = reinterpret_cast< FittingMethod * >(argp5);
  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 (extractArray(swig_obj[7],&temp8)) {
      arg8 = &temp8;
    } else {
      if (SWIG_ConvertPtr(swig_obj[7],(void **) &arg8,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Array temp8 ;
  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);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg5 = reinterpret_cast< FittingMethod * >(argp5);
  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 (extractArray(swig_obj[7],&temp8)) {
      arg8 = &temp8;
    } else {
      if (SWIG_ConvertPtr(swig_obj[7],(void **) &arg8,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg5 = reinterpret_cast< FittingMethod * >(argp5);
  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 *SWIGUNUSEDPARM(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 ;
  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);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg5 = reinterpret_cast< FittingMethod * >(argp5);
  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 *SWIGUNUSEDPARM(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 ;
  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);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg5 = reinterpret_cast< FittingMethod * >(argp5);
  {
    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 *SWIGUNUSEDPARM(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 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Array temp7 ;
  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);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg4 = reinterpret_cast< FittingMethod * >(argp4);
  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 (extractArray(swig_obj[6],&temp7)) {
      arg7 = &temp7;
    } else {
      if (SWIG_ConvertPtr(swig_obj[6],(void **) &arg7,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Array temp7 ;
  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);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg4 = reinterpret_cast< FittingMethod * >(argp4);
  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 (extractArray(swig_obj[6],&temp7)) {
      arg7 = &temp7;
    } else {
      if (SWIG_ConvertPtr(swig_obj[6],(void **) &arg7,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg4 = reinterpret_cast< FittingMethod * >(argp4);
  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 *SWIGUNUSEDPARM(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 ;
  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);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg4 = reinterpret_cast< FittingMethod * >(argp4);
  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 *SWIGUNUSEDPARM(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 ;
  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);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FittingMethod,  0  | 0);
  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 &""'"); 
  }
  arg4 = reinterpret_cast< FittingMethod * >(argp4);
  {
    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;
    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_FittingMethod, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FittedBondDiscountCurve__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    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_FittingMethod, 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_FittedBondDiscountCurve__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      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_FittingMethod, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FittedBondDiscountCurve__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    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_FittingMethod, 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_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;
    {
      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_FittingMethod, 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_FittedBondDiscountCurve__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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_FittingMethod, 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_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 {
                    /* wrapped Array? */
                    Array* v;
                    if (SWIG_ConvertPtr(argv[6],(void **) &v,
                        SWIGTYPE_p_Array,0) != -1)
                    _v = 1;
                    else
                    _v = 0;
                  }
                }
                if (_v) {
                  return _wrap_new_FittedBondDiscountCurve__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      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_FittingMethod, 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_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;
    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_FittingMethod, 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_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 {
                    /* wrapped Array? */
                    Array* v;
                    if (SWIG_ConvertPtr(argv[6],(void **) &v,
                        SWIGTYPE_p_Array,0) != -1)
                    _v = 1;
                    else
                    _v = 0;
                  }
                }
                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;
    {
      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_FittingMethod, 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_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 {
                      /* wrapped Array? */
                      Array* v;
                      if (SWIG_ConvertPtr(argv[7],(void **) &v,
                          SWIGTYPE_p_Array,0) != -1)
                      _v = 1;
                      else
                      _v = 0;
                    }
                  }
                  if (_v) {
                    return _wrap_new_FittedBondDiscountCurve__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      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_FittingMethod, 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_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 {
                      /* wrapped Array? */
                      Array* v;
                      if (SWIG_ConvertPtr(argv[7],(void **) &v,
                          SWIGTYPE_p_Array,0) != -1)
                      _v = 1;
                      else
                      _v = 0;
                    }
                  }
                  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 *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FittingMethod, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FittedBondDiscountCurve(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExponentialSplinesFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_1(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExponentialSplinesFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_2(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExponentialSplinesFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExponentialSplinesFitting", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ExponentialSplinesFitting__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ExponentialSplinesFitting__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 &)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExponentialSplinesFitting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ExponentialSplinesFitting *arg1 = (ExponentialSplinesFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExponentialSplinesFitting, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExponentialSplinesFitting" "', argument " "1"" of type '" "ExponentialSplinesFitting *""'"); 
  }
  arg1 = reinterpret_cast< ExponentialSplinesFitting * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_ExponentialSplinesFitting, 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  NelsonSiegelFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NelsonSiegelFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NelsonSiegelFitting__SWIG_1(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NelsonSiegelFitting, SWIG_POINTER_NEW |  0 );
  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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  NelsonSiegelFitting *arg1 = (NelsonSiegelFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NelsonSiegelFitting, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NelsonSiegelFitting" "', argument " "1"" of type '" "NelsonSiegelFitting *""'"); 
  }
  arg1 = reinterpret_cast< NelsonSiegelFitting * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_NelsonSiegelFitting, 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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  SvenssonFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SvenssonFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SvenssonFitting__SWIG_1(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SvenssonFitting, SWIG_POINTER_NEW |  0 );
  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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SvenssonFitting *arg1 = (SvenssonFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SvenssonFitting, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SvenssonFitting" "', argument " "1"" of type '" "SvenssonFitting *""'"); 
  }
  arg1 = reinterpret_cast< SvenssonFitting * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_SvenssonFitting, 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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CubicBSplinesFitting, 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_CubicBSplinesFitting__SWIG_1(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CubicBSplinesFitting, 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_CubicBSplinesFitting__SWIG_2(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CubicBSplinesFitting, 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_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;
    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;
    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;
    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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CubicBSplinesFitting *arg1 = (CubicBSplinesFitting *) 0 ;
  Integer arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 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;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CubicBSplinesFitting, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicBSplinesFitting_basisFunction" "', argument " "1"" of type '" "CubicBSplinesFitting *""'"); 
  }
  arg1 = reinterpret_cast< CubicBSplinesFitting * >(argp1);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CubicBSplinesFitting *arg1 = (CubicBSplinesFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CubicBSplinesFitting, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CubicBSplinesFitting" "', argument " "1"" of type '" "CubicBSplinesFitting *""'"); 
  }
  arg1 = reinterpret_cast< CubicBSplinesFitting * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_CubicBSplinesFitting, 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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SimplePolynomialFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimplePolynomialFitting__SWIG_1(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SimplePolynomialFitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimplePolynomialFitting__SWIG_2(PyObject *SWIGUNUSEDPARM(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");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SimplePolynomialFitting, SWIG_POINTER_NEW |  0 );
  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;
    {
      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;
    {
      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;
    {
      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 {
            /* wrapped Array? */
            Array* v;
            if (SWIG_ConvertPtr(argv[2],(void **) &v,
                SWIGTYPE_p_Array,0) != -1)
            _v = 1;
            else
            _v = 0;
          }
        }
        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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimplePolynomialFitting *arg1 = (SimplePolynomialFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimplePolynomialFitting, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimplePolynomialFitting" "', argument " "1"" of type '" "SimplePolynomialFitting *""'"); 
  }
  arg1 = reinterpret_cast< SimplePolynomialFitting * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_SimplePolynomialFitting, 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_ForwardCurve__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Forward_settlementDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_isExpired(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_incomeDiscountCurve(PyObject *SWIGUNUSEDPARM(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 >(static_cast< const Handle< YieldTermStructure >& >(result))), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_spotValue(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Forward(PyObject *SWIGUNUSEDPARM(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_FixedRateBondForward__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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_FixedRateBondForward_forwardPrice(PyObject *SWIGUNUSEDPARM(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] ;
  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_FixedRateBondForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateBondForward_forwardPrice" "', 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 {
      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_FixedRateBondForward_cleanForwardPrice(PyObject *SWIGUNUSEDPARM(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] ;
  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_FixedRateBondForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateBondForward_cleanForwardPrice" "', 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 {
      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_FixedRateBondForward(PyObject *SWIGUNUSEDPARM(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_Position(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(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 == 6) {
    int _v;
    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 == 7) {
    int _v;
    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;
    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");
  return 0;
}


SWIGINTERN PyObject *_wrap_ForwardRateAgreement_fixingDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardRateAgreement_spotIncome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardRateAgreement const > tempshared1 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "ForwardRateAgreement_spotIncome", 2, 2, swig_obj)) SWIG_fail;
  {
    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_spotIncome" "', 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));
    }
  }
  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 '" "ForwardRateAgreement_spotIncome" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardRateAgreement_spotIncome" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Real)((ForwardRateAgreement 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_ForwardRateAgreement_spotValue(PyObject *SWIGUNUSEDPARM(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_spotValue" "', 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)->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_ForwardRateAgreement_forwardRate(PyObject *SWIGUNUSEDPARM(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(static_cast< const InterestRate& >(result))), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardRateAgreement(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrate__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_setParams(PyObject *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Gaussian1dSwaptionEngine__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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___call__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_new_GaussLaguerreIntegration__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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_GaussLaguerreIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussLaguerreIntegration *arg1 = (GaussLaguerreIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussLaguerreIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLaguerreIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLaguerreIntegration___call__" "', argument " "1"" of type '" "GaussLaguerreIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussLaguerreIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussLaguerreIntegration___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_GaussLaguerreIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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_GaussHermiteIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussHermiteIntegration *arg1 = (GaussHermiteIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussHermiteIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussHermiteIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussHermiteIntegration___call__" "', argument " "1"" of type '" "GaussHermiteIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussHermiteIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussHermiteIntegration___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_GaussHermiteIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussJacobiIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussJacobiIntegration *arg1 = (GaussJacobiIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussJacobiIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussJacobiIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussJacobiIntegration___call__" "', argument " "1"" of type '" "GaussJacobiIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussJacobiIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussJacobiIntegration___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_GaussJacobiIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussHyperbolicIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussHyperbolicIntegration *arg1 = (GaussHyperbolicIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussHyperbolicIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussHyperbolicIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussHyperbolicIntegration___call__" "', argument " "1"" of type '" "GaussHyperbolicIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussHyperbolicIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussHyperbolicIntegration___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_GaussHyperbolicIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussLegendreIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussLegendreIntegration *arg1 = (GaussLegendreIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussLegendreIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLegendreIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLegendreIntegration___call__" "', argument " "1"" of type '" "GaussLegendreIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussLegendreIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussLegendreIntegration___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_GaussLegendreIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussChebyshevIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussChebyshevIntegration *arg1 = (GaussChebyshevIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussChebyshevIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussChebyshevIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussChebyshevIntegration___call__" "', argument " "1"" of type '" "GaussChebyshevIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussChebyshevIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussChebyshevIntegration___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_GaussChebyshevIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussChebyshev2ndIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussChebyshev2ndIntegration *arg1 = (GaussChebyshev2ndIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussChebyshev2ndIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussChebyshev2ndIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussChebyshev2ndIntegration___call__" "', argument " "1"" of type '" "GaussChebyshev2ndIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussChebyshev2ndIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussChebyshev2ndIntegration___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_GaussChebyshev2ndIntegration(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussGegenbauerIntegration___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussGegenbauerIntegration *arg1 = (GaussGegenbauerIntegration *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussGegenbauerIntegration___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussGegenbauerIntegration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussGegenbauerIntegration___call__" "', argument " "1"" of type '" "GaussGegenbauerIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussGegenbauerIntegration * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussGegenbauerIntegration___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_GaussGegenbauerIntegration(PyObject *SWIGUNUSEDPARM(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_SampleNumber_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Real > *arg1 = (Sample< 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_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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Array > *arg1 = (Sample< Array > *) 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_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 = 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((new Array(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampleArray_weight(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
  
  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 = 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LecuyerUniformRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KnuthUniformRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MersenneTwisterUniformRng(PyObject *SWIGUNUSEDPARM(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_UniformRandomGenerator__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UniformRandomGenerator_nextValue(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitKnuthGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitMersenneTwisterGaussianRng(PyObject *SWIGUNUSEDPARM(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_BoxMullerLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerKnuthGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerMersenneTwisterGaussianRng(PyObject *SWIGUNUSEDPARM(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_MoroInvCumulativeLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeKnuthGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRng(PyObject *SWIGUNUSEDPARM(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_InvCumulativeLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeLecuyerGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeKnuthGaussianRng(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeMersenneTwisterGaussianRng(PyObject *SWIGUNUSEDPARM(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_GaussianRandomGenerator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const Sample< Real >& >(result))), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianRandomGenerator_nextValue(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_SobolBrownianBridgeRsg(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_LecuyerUniformRsg__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_UniformRandomSequenceGenerator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_MoroInvCumulativeHaltonGaussianRsg__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_InvCumulativeLecuyerGaussianRsg__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_InvCumulativeHaltonGaussianRsg__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_GaussianRandomSequenceGenerator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_getCovariance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Matrix *arg2 = 0 ;
  Array temp1 ;
  Matrix temp2 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "getCovariance", 2, 2, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg2 = &temp2;
    } else {
      SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path___len__(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Path > 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_value" "', argument " "1"" of type '" "Sample< Path > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Path > * >(argp1);
  {
    try {
      result = 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((new Path(static_cast< const Path& >(result))), SWIGTYPE_p_Path, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplePath_weight(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< MultiPath > 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_value" "', argument " "1"" of type '" "Sample< MultiPath > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< MultiPath > * >(argp1);
  {
    try {
      result = 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((new MultiPath(static_cast< const MultiPath& >(result))), SWIGTYPE_p_MultiPath, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampleMultiPath_weight(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  GaussianMultiPathGenerator *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 = (GaussianMultiPathGenerator *)new_GaussianMultiPathGenerator__SWIG_0((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_GaussianMultiPathGenerator, 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_1(PyObject *SWIGUNUSEDPARM(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 ;
  GaussianMultiPathGenerator *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 = (GaussianMultiPathGenerator *)new_GaussianMultiPathGenerator__SWIG_0((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_GaussianMultiPathGenerator, 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;
    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_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    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_0(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"
    "    GaussianMultiPathGenerator::GaussianMultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,std::vector< Time,std::allocator< Time > > const &,GaussianRandomSequenceGenerator const &,bool)\n"
    "    GaussianMultiPathGenerator::GaussianMultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,std::vector< Time,std::allocator< Time > > const &,GaussianRandomSequenceGenerator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussianMultiPathGenerator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussianMultiPathGenerator *arg1 = (GaussianMultiPathGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< MultiPath > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianMultiPathGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMultiPathGenerator_next" "', argument " "1"" of type '" "GaussianMultiPathGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianMultiPathGenerator * >(argp1);
  {
    try {
      result = ((GaussianMultiPathGenerator 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< MultiPath >(static_cast< const Sample< MultiPath >& >(result))), SWIGTYPE_p_SampleT_MultiPath_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianMultiPathGenerator_antithetic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussianMultiPathGenerator *arg1 = (GaussianMultiPathGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< MultiPath > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianMultiPathGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMultiPathGenerator_antithetic" "', argument " "1"" of type '" "GaussianMultiPathGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianMultiPathGenerator * >(argp1);
  {
    try {
      result = ((GaussianMultiPathGenerator 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((new Sample< MultiPath >(static_cast< const Sample< MultiPath >& >(result))), SWIGTYPE_p_SampleT_MultiPath_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianMultiPathGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  GaussianMultiPathGenerator *arg1 = (GaussianMultiPathGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianMultiPathGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianMultiPathGenerator" "', argument " "1"" of type '" "GaussianMultiPathGenerator *""'"); 
  }
  arg1 = reinterpret_cast< GaussianMultiPathGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_GaussianMultiPathGenerator, 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_BrownianBridge__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Array temp1 ;
  Array temp2 ;
  Array temp3 ;
  PyObject *swig_obj[3] ;
  TridiagonalOperator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TridiagonalOperator", 3, 3, swig_obj)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    if (extractArray(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      if (SWIG_ConvertPtr(swig_obj[2],(void **) &arg3,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_applyTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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(static_cast< const Array& >(result))), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_size(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } 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(static_cast< const TridiagonalOperator& >(result))), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___add__(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const TridiagonalOperator& >(result))), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___isub__(PyObject *SWIGUNUSEDPARM(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(static_cast< const TridiagonalOperator& >(result))), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___imul__(PyObject *SWIGUNUSEDPARM(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(static_cast< const TridiagonalOperator& >(result))), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___rmul__(PyObject *SWIGUNUSEDPARM(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(static_cast< const 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 *SWIGUNUSEDPARM(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(static_cast< const TridiagonalOperator& >(result))), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TridiagonalOperator(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  SampledCurve *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (extractArray(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      if (SWIG_ConvertPtr(swig_obj[0],(void **) &arg1,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    {
      /* 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 {
        /* wrapped Array? */
        Array* v;
        if (SWIG_ConvertPtr(argv[0],(void **) &v,
            SWIGTYPE_p_Array,0) != -1)
        _v = 1;
        else
        _v = 0;
      }
    }
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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 *SWIGUNUSEDPARM(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_delete_BrownianGeneratorFactory(PyObject *SWIGUNUSEDPARM(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_MTBrownianGeneratorFactory__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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 *SWIGUNUSEDPARM(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_delete_SobolBrownianGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianGenerator *arg1 = (SobolBrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolBrownianGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SobolBrownianGenerator" "', argument " "1"" of type '" "SobolBrownianGenerator *""'"); 
  }
  arg1 = reinterpret_cast< SobolBrownianGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_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_SobolBrownianGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SobolBrownianGeneratorFactory__SWIG_0(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    {
      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;
    {
      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;
    {
      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 *SWIGUNUSEDPARM(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_HestonSLVMCModel__SWIG_0(PyObject *SWIGUNUSEDPARM(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,arg5,arg6,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 *SWIGUNUSEDPARM(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,arg5,arg6,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 *SWIGUNUSEDPARM(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,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_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_3(PyObject *SWIGUNUSEDPARM(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,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_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_4(PyObject *SWIGUNUSEDPARM(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,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,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");
    }
  }
  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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_Statistics_samples(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_correlation(PyObject *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_reset(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_MultipleStatistics_add__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_correlation(PyObject *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_reset(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_SequenceStatistics_add__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_correlation(PyObject *SWIGUNUSEDPARM(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(static_cast< const Matrix& >(result))), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_reset(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 ;
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  
  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 (extractArray(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      if (SWIG_ConvertPtr(swig_obj[1],(void **) &arg2,SWIGTYPE_p_Array,1) == -1) {
        PyErr_SetString(PyExc_TypeError, "Array expected");
        return NULL;
      }
    }
  }
  {
    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;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      if (_v) {
        return _wrap_MultipleIncrementalStatistics_add__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    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;
    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 {
          /* wrapped Array? */
          Array* v;
          if (SWIG_ConvertPtr(argv[1],(void **) &v,
              SWIGTYPE_p_Array,0) != -1)
          _v = 1;
          else
          _v = 0;
        }
      }
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_timeFromReference(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_referenceDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_maxDate(PyObject *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_maxTime(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    {
      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;
    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;
    {
      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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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 *SWIGUNUSEDPARM(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 *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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  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 *SWIGUNUSEDPARM(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 ;
  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);
          return NULL;
        }
      } 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);
            return NULL;
          }
          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);
              return NULL;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          return NULL;
        }
      }
      arg6 = &temp6;
    } else {
      SWIG_ConvertPtr(swig_obj[5],(void **) &arg6,SWIGTYPE_p_Matrix,1);
    }
  }
  {
    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;
    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;
    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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              if (_v) {
                return _wrap_new_CapFloorTermVolSurface__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      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;
    {
      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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              if (_v) {
                return _wrap_new_CapFloorTermVolSurface__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    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;
    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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              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;
    {
      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;
    {
      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 {
                  Matrix* m;
                  if (SWIG_ConvertPtr(argv[5],(void **) &m,
                      SWIGTYPE_p_Matrix,0) != -1)
                  _v = 1;
                  else
                  _v = 0;
                }
              }
              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 *SWIGUNUSEDPARM(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(static_cast< const Date& >(result))), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_minStrike(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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(static_cast< const DayCounter& >(result))), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_calendar(PyObject *SWIGUNUSEDPARM(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(static_cast< const Calendar& >(result))), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_settlementDays(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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_delete_StrippedOptionletBase(PyObject *SWIGUNUSEDPARM(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_OptionletStripper1(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwaption_probabilities(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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,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< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatFloatSwaption_underlyingValue(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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_enableTracing(PyObject *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 >(static_cast< const 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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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;
    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;
    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;
    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;
    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;
    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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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 *SWIGUNUSEDPARM(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);
}

static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "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, NULL},
	 { "Period_units", _wrap_Period_units, METH_O, NULL},
	 { "Period_frequency", _wrap_Period_frequency, METH_O, NULL},
	 { "new_Period", _wrap_new_Period, METH_VARARGS, NULL},
	 { "Period___str__", _wrap_Period___str__, METH_O, NULL},
	 { "Period___repr__", _wrap_Period___repr__, METH_O, NULL},
	 { "Period___neg__", _wrap_Period___neg__, METH_O, NULL},
	 { "Period___add__", _wrap_Period___add__, METH_VARARGS, NULL},
	 { "Period___sub__", _wrap_Period___sub__, METH_VARARGS, NULL},
	 { "Period___mul__", _wrap_Period___mul__, METH_VARARGS, NULL},
	 { "Period___rmul__", _wrap_Period___rmul__, METH_VARARGS, NULL},
	 { "Period___lt__", _wrap_Period___lt__, METH_VARARGS, NULL},
	 { "Period___gt__", _wrap_Period___gt__, METH_VARARGS, NULL},
	 { "Period___le__", _wrap_Period___le__, METH_VARARGS, NULL},
	 { "Period___ge__", _wrap_Period___ge__, METH_VARARGS, NULL},
	 { "Period___eq__", _wrap_Period___eq__, METH_VARARGS, NULL},
	 { "Period___cmp__", _wrap_Period___cmp__, METH_VARARGS, NULL},
	 { "delete_Period", _wrap_delete_Period, METH_O, NULL},
	 { "Period_swigregister", Period_swigregister, METH_O, NULL},
	 { "Period_swiginit", Period_swiginit, METH_VARARGS, NULL},
	 { "PeriodVector_iterator", _wrap_PeriodVector_iterator, METH_O, NULL},
	 { "PeriodVector___nonzero__", _wrap_PeriodVector___nonzero__, METH_O, NULL},
	 { "PeriodVector___bool__", _wrap_PeriodVector___bool__, METH_O, NULL},
	 { "PeriodVector___len__", _wrap_PeriodVector___len__, METH_O, NULL},
	 { "PeriodVector___getslice__", _wrap_PeriodVector___getslice__, METH_VARARGS, NULL},
	 { "PeriodVector___setslice__", _wrap_PeriodVector___setslice__, METH_VARARGS, NULL},
	 { "PeriodVector___delslice__", _wrap_PeriodVector___delslice__, METH_VARARGS, NULL},
	 { "PeriodVector___delitem__", _wrap_PeriodVector___delitem__, METH_VARARGS, NULL},
	 { "PeriodVector___getitem__", _wrap_PeriodVector___getitem__, METH_VARARGS, NULL},
	 { "PeriodVector___setitem__", _wrap_PeriodVector___setitem__, METH_VARARGS, NULL},
	 { "PeriodVector_pop", _wrap_PeriodVector_pop, METH_O, NULL},
	 { "PeriodVector_append", _wrap_PeriodVector_append, METH_VARARGS, NULL},
	 { "PeriodVector_empty", _wrap_PeriodVector_empty, METH_O, NULL},
	 { "PeriodVector_size", _wrap_PeriodVector_size, METH_O, NULL},
	 { "PeriodVector_swap", _wrap_PeriodVector_swap, METH_VARARGS, NULL},
	 { "PeriodVector_begin", _wrap_PeriodVector_begin, METH_O, NULL},
	 { "PeriodVector_end", _wrap_PeriodVector_end, METH_O, NULL},
	 { "PeriodVector_rbegin", _wrap_PeriodVector_rbegin, METH_O, NULL},
	 { "PeriodVector_rend", _wrap_PeriodVector_rend, METH_O, NULL},
	 { "PeriodVector_clear", _wrap_PeriodVector_clear, METH_O, NULL},
	 { "PeriodVector_get_allocator", _wrap_PeriodVector_get_allocator, METH_O, NULL},
	 { "PeriodVector_pop_back", _wrap_PeriodVector_pop_back, METH_O, NULL},
	 { "PeriodVector_erase", _wrap_PeriodVector_erase, METH_VARARGS, NULL},
	 { "new_PeriodVector", _wrap_new_PeriodVector, METH_VARARGS, NULL},
	 { "PeriodVector_push_back", _wrap_PeriodVector_push_back, METH_VARARGS, NULL},
	 { "PeriodVector_front", _wrap_PeriodVector_front, METH_O, NULL},
	 { "PeriodVector_back", _wrap_PeriodVector_back, METH_O, NULL},
	 { "PeriodVector_assign", _wrap_PeriodVector_assign, METH_VARARGS, NULL},
	 { "PeriodVector_resize", _wrap_PeriodVector_resize, METH_VARARGS, NULL},
	 { "PeriodVector_insert", _wrap_PeriodVector_insert, METH_VARARGS, NULL},
	 { "PeriodVector_reserve", _wrap_PeriodVector_reserve, METH_VARARGS, NULL},
	 { "PeriodVector_capacity", _wrap_PeriodVector_capacity, METH_O, NULL},
	 { "delete_PeriodVector", _wrap_delete_PeriodVector, METH_O, NULL},
	 { "PeriodVector_swigregister", PeriodVector_swigregister, METH_O, NULL},
	 { "PeriodVector_swiginit", PeriodVector_swiginit, METH_VARARGS, NULL},
	 { "Date_weekday", _wrap_Date_weekday, METH_O, NULL},
	 { "Date_dayOfMonth", _wrap_Date_dayOfMonth, METH_O, NULL},
	 { "Date_dayOfYear", _wrap_Date_dayOfYear, METH_O, NULL},
	 { "Date_month", _wrap_Date_month, METH_O, NULL},
	 { "Date_year", _wrap_Date_year, METH_O, NULL},
	 { "Date_hours", _wrap_Date_hours, METH_O, NULL},
	 { "Date_minutes", _wrap_Date_minutes, METH_O, NULL},
	 { "Date_seconds", _wrap_Date_seconds, METH_O, NULL},
	 { "Date_milliseconds", _wrap_Date_milliseconds, METH_O, NULL},
	 { "Date_microseconds", _wrap_Date_microseconds, METH_O, NULL},
	 { "Date_fractionOfDay", _wrap_Date_fractionOfDay, METH_O, NULL},
	 { "Date_fractionOfSecond", _wrap_Date_fractionOfSecond, METH_O, NULL},
	 { "Date_serialNumber", _wrap_Date_serialNumber, METH_O, NULL},
	 { "Date_isLeap", _wrap_Date_isLeap, METH_O, NULL},
	 { "Date_minDate", _wrap_Date_minDate, METH_NOARGS, NULL},
	 { "Date_maxDate", _wrap_Date_maxDate, METH_NOARGS, NULL},
	 { "Date_todaysDate", _wrap_Date_todaysDate, METH_NOARGS, NULL},
	 { "Date_localDateTime", _wrap_Date_localDateTime, METH_NOARGS, NULL},
	 { "Date_universalDateTime", _wrap_Date_universalDateTime, METH_NOARGS, NULL},
	 { "Date_endOfMonth", _wrap_Date_endOfMonth, METH_O, NULL},
	 { "Date_isEndOfMonth", _wrap_Date_isEndOfMonth, METH_O, NULL},
	 { "Date_nextWeekday", _wrap_Date_nextWeekday, METH_VARARGS, NULL},
	 { "Date_nthWeekday", _wrap_Date_nthWeekday, METH_VARARGS, NULL},
	 { "Date___add__", _wrap_Date___add__, METH_VARARGS, NULL},
	 { "new_Date", _wrap_new_Date, METH_VARARGS, NULL},
	 { "Date_weekdayNumber", _wrap_Date_weekdayNumber, METH_O, NULL},
	 { "Date___str__", _wrap_Date___str__, METH_O, NULL},
	 { "Date___repr__", _wrap_Date___repr__, METH_O, NULL},
	 { "Date_ISO", _wrap_Date_ISO, METH_O, NULL},
	 { "Date___sub__", _wrap_Date___sub__, METH_VARARGS, NULL},
	 { "Date___eq__", _wrap_Date___eq__, METH_VARARGS, NULL},
	 { "Date___cmp__", _wrap_Date___cmp__, METH_VARARGS, NULL},
	 { "Date___nonzero__", _wrap_Date___nonzero__, METH_O, NULL},
	 { "Date___bool__", _wrap_Date___bool__, METH_O, NULL},
	 { "Date___hash__", _wrap_Date___hash__, METH_O, NULL},
	 { "Date___lt__", _wrap_Date___lt__, METH_VARARGS, NULL},
	 { "Date___gt__", _wrap_Date___gt__, METH_VARARGS, NULL},
	 { "Date___le__", _wrap_Date___le__, METH_VARARGS, NULL},
	 { "Date___ge__", _wrap_Date___ge__, METH_VARARGS, NULL},
	 { "Date___ne__", _wrap_Date___ne__, METH_VARARGS, NULL},
	 { "delete_Date", _wrap_delete_Date, METH_O, NULL},
	 { "Date_swigregister", Date_swigregister, METH_O, NULL},
	 { "Date_swiginit", Date_swiginit, METH_VARARGS, NULL},
	 { "DateParser_parseFormatted", _wrap_DateParser_parseFormatted, METH_VARARGS, NULL},
	 { "DateParser_parseISO", _wrap_DateParser_parseISO, METH_O, NULL},
	 { "DateParser_parse", _wrap_DateParser_parse, METH_VARARGS, NULL},
	 { "new_DateParser", _wrap_new_DateParser, METH_NOARGS, NULL},
	 { "delete_DateParser", _wrap_delete_DateParser, METH_O, NULL},
	 { "DateParser_swigregister", DateParser_swigregister, METH_O, NULL},
	 { "DateParser_swiginit", DateParser_swiginit, METH_VARARGS, NULL},
	 { "PeriodParser_parse", _wrap_PeriodParser_parse, METH_O, NULL},
	 { "new_PeriodParser", _wrap_new_PeriodParser, METH_NOARGS, NULL},
	 { "delete_PeriodParser", _wrap_delete_PeriodParser, METH_O, NULL},
	 { "PeriodParser_swigregister", PeriodParser_swigregister, METH_O, NULL},
	 { "PeriodParser_swiginit", PeriodParser_swiginit, METH_VARARGS, NULL},
	 { "DateVector_iterator", _wrap_DateVector_iterator, METH_O, NULL},
	 { "DateVector___nonzero__", _wrap_DateVector___nonzero__, METH_O, NULL},
	 { "DateVector___bool__", _wrap_DateVector___bool__, METH_O, NULL},
	 { "DateVector___len__", _wrap_DateVector___len__, METH_O, NULL},
	 { "DateVector___getslice__", _wrap_DateVector___getslice__, METH_VARARGS, NULL},
	 { "DateVector___setslice__", _wrap_DateVector___setslice__, METH_VARARGS, NULL},
	 { "DateVector___delslice__", _wrap_DateVector___delslice__, METH_VARARGS, NULL},
	 { "DateVector___delitem__", _wrap_DateVector___delitem__, METH_VARARGS, NULL},
	 { "DateVector___getitem__", _wrap_DateVector___getitem__, METH_VARARGS, NULL},
	 { "DateVector___setitem__", _wrap_DateVector___setitem__, METH_VARARGS, NULL},
	 { "DateVector_pop", _wrap_DateVector_pop, METH_O, NULL},
	 { "DateVector_append", _wrap_DateVector_append, METH_VARARGS, NULL},
	 { "DateVector_empty", _wrap_DateVector_empty, METH_O, NULL},
	 { "DateVector_size", _wrap_DateVector_size, METH_O, NULL},
	 { "DateVector_swap", _wrap_DateVector_swap, METH_VARARGS, NULL},
	 { "DateVector_begin", _wrap_DateVector_begin, METH_O, NULL},
	 { "DateVector_end", _wrap_DateVector_end, METH_O, NULL},
	 { "DateVector_rbegin", _wrap_DateVector_rbegin, METH_O, NULL},
	 { "DateVector_rend", _wrap_DateVector_rend, METH_O, NULL},
	 { "DateVector_clear", _wrap_DateVector_clear, METH_O, NULL},
	 { "DateVector_get_allocator", _wrap_DateVector_get_allocator, METH_O, NULL},
	 { "DateVector_pop_back", _wrap_DateVector_pop_back, METH_O, NULL},
	 { "DateVector_erase", _wrap_DateVector_erase, METH_VARARGS, NULL},
	 { "new_DateVector", _wrap_new_DateVector, METH_VARARGS, NULL},
	 { "DateVector_push_back", _wrap_DateVector_push_back, METH_VARARGS, NULL},
	 { "DateVector_front", _wrap_DateVector_front, METH_O, NULL},
	 { "DateVector_back", _wrap_DateVector_back, METH_O, NULL},
	 { "DateVector_assign", _wrap_DateVector_assign, METH_VARARGS, NULL},
	 { "DateVector_resize", _wrap_DateVector_resize, METH_VARARGS, NULL},
	 { "DateVector_insert", _wrap_DateVector_insert, METH_VARARGS, NULL},
	 { "DateVector_reserve", _wrap_DateVector_reserve, METH_VARARGS, NULL},
	 { "DateVector_capacity", _wrap_DateVector_capacity, METH_O, NULL},
	 { "delete_DateVector", _wrap_delete_DateVector, METH_O, NULL},
	 { "DateVector_swigregister", DateVector_swigregister, METH_O, NULL},
	 { "DateVector_swiginit", DateVector_swiginit, METH_VARARGS, NULL},
	 { "daysBetween", _wrap_daysBetween, METH_VARARGS, NULL},
	 { "IMM_isIMMdate", _wrap_IMM_isIMMdate, METH_VARARGS, NULL},
	 { "IMM_isIMMcode", _wrap_IMM_isIMMcode, METH_VARARGS, NULL},
	 { "IMM_code", _wrap_IMM_code, METH_O, NULL},
	 { "IMM_date", _wrap_IMM_date, METH_VARARGS, NULL},
	 { "IMM_nextDate", _wrap_IMM_nextDate, METH_VARARGS, NULL},
	 { "IMM_nextCode", _wrap_IMM_nextCode, METH_VARARGS, NULL},
	 { "new_IMM", _wrap_new_IMM, METH_NOARGS, NULL},
	 { "delete_IMM", _wrap_delete_IMM, METH_O, NULL},
	 { "IMM_swigregister", IMM_swigregister, METH_O, NULL},
	 { "IMM_swiginit", IMM_swiginit, METH_VARARGS, NULL},
	 { "ASX_isASXdate", _wrap_ASX_isASXdate, METH_VARARGS, NULL},
	 { "ASX_isASXcode", _wrap_ASX_isASXcode, METH_VARARGS, NULL},
	 { "ASX_code", _wrap_ASX_code, METH_O, NULL},
	 { "ASX_date", _wrap_ASX_date, METH_VARARGS, NULL},
	 { "ASX_nextDate", _wrap_ASX_nextDate, METH_VARARGS, NULL},
	 { "ASX_nextCode", _wrap_ASX_nextCode, METH_VARARGS, NULL},
	 { "new_ASX", _wrap_new_ASX, METH_NOARGS, NULL},
	 { "delete_ASX", _wrap_delete_ASX, METH_O, NULL},
	 { "ASX_swigregister", ASX_swigregister, METH_O, NULL},
	 { "ASX_swiginit", ASX_swiginit, METH_VARARGS, NULL},
	 { "IntVector_iterator", _wrap_IntVector_iterator, METH_O, NULL},
	 { "IntVector___nonzero__", _wrap_IntVector___nonzero__, METH_O, NULL},
	 { "IntVector___bool__", _wrap_IntVector___bool__, METH_O, NULL},
	 { "IntVector___len__", _wrap_IntVector___len__, METH_O, NULL},
	 { "IntVector___getslice__", _wrap_IntVector___getslice__, METH_VARARGS, NULL},
	 { "IntVector___setslice__", _wrap_IntVector___setslice__, METH_VARARGS, NULL},
	 { "IntVector___delslice__", _wrap_IntVector___delslice__, METH_VARARGS, NULL},
	 { "IntVector___delitem__", _wrap_IntVector___delitem__, METH_VARARGS, NULL},
	 { "IntVector___getitem__", _wrap_IntVector___getitem__, METH_VARARGS, NULL},
	 { "IntVector___setitem__", _wrap_IntVector___setitem__, METH_VARARGS, NULL},
	 { "IntVector_pop", _wrap_IntVector_pop, METH_O, NULL},
	 { "IntVector_append", _wrap_IntVector_append, METH_VARARGS, NULL},
	 { "IntVector_empty", _wrap_IntVector_empty, METH_O, NULL},
	 { "IntVector_size", _wrap_IntVector_size, METH_O, NULL},
	 { "IntVector_swap", _wrap_IntVector_swap, METH_VARARGS, NULL},
	 { "IntVector_begin", _wrap_IntVector_begin, METH_O, NULL},
	 { "IntVector_end", _wrap_IntVector_end, METH_O, NULL},
	 { "IntVector_rbegin", _wrap_IntVector_rbegin, METH_O, NULL},
	 { "IntVector_rend", _wrap_IntVector_rend, METH_O, NULL},
	 { "IntVector_clear", _wrap_IntVector_clear, METH_O, NULL},
	 { "IntVector_get_allocator", _wrap_IntVector_get_allocator, METH_O, NULL},
	 { "IntVector_pop_back", _wrap_IntVector_pop_back, METH_O, NULL},
	 { "IntVector_erase", _wrap_IntVector_erase, METH_VARARGS, NULL},
	 { "new_IntVector", _wrap_new_IntVector, METH_VARARGS, NULL},
	 { "IntVector_push_back", _wrap_IntVector_push_back, METH_VARARGS, NULL},
	 { "IntVector_front", _wrap_IntVector_front, METH_O, NULL},
	 { "IntVector_back", _wrap_IntVector_back, METH_O, NULL},
	 { "IntVector_assign", _wrap_IntVector_assign, METH_VARARGS, NULL},
	 { "IntVector_resize", _wrap_IntVector_resize, METH_VARARGS, NULL},
	 { "IntVector_insert", _wrap_IntVector_insert, METH_VARARGS, NULL},
	 { "IntVector_reserve", _wrap_IntVector_reserve, METH_VARARGS, NULL},
	 { "IntVector_capacity", _wrap_IntVector_capacity, METH_O, NULL},
	 { "delete_IntVector", _wrap_delete_IntVector, METH_O, NULL},
	 { "IntVector_swigregister", IntVector_swigregister, METH_O, NULL},
	 { "IntVector_swiginit", IntVector_swiginit, METH_VARARGS, NULL},
	 { "UnsignedIntVector_iterator", _wrap_UnsignedIntVector_iterator, METH_O, NULL},
	 { "UnsignedIntVector___nonzero__", _wrap_UnsignedIntVector___nonzero__, METH_O, NULL},
	 { "UnsignedIntVector___bool__", _wrap_UnsignedIntVector___bool__, METH_O, NULL},
	 { "UnsignedIntVector___len__", _wrap_UnsignedIntVector___len__, METH_O, NULL},
	 { "UnsignedIntVector___getslice__", _wrap_UnsignedIntVector___getslice__, METH_VARARGS, NULL},
	 { "UnsignedIntVector___setslice__", _wrap_UnsignedIntVector___setslice__, METH_VARARGS, NULL},
	 { "UnsignedIntVector___delslice__", _wrap_UnsignedIntVector___delslice__, METH_VARARGS, NULL},
	 { "UnsignedIntVector___delitem__", _wrap_UnsignedIntVector___delitem__, METH_VARARGS, NULL},
	 { "UnsignedIntVector___getitem__", _wrap_UnsignedIntVector___getitem__, METH_VARARGS, NULL},
	 { "UnsignedIntVector___setitem__", _wrap_UnsignedIntVector___setitem__, METH_VARARGS, NULL},
	 { "UnsignedIntVector_pop", _wrap_UnsignedIntVector_pop, METH_O, NULL},
	 { "UnsignedIntVector_append", _wrap_UnsignedIntVector_append, METH_VARARGS, NULL},
	 { "UnsignedIntVector_empty", _wrap_UnsignedIntVector_empty, METH_O, NULL},
	 { "UnsignedIntVector_size", _wrap_UnsignedIntVector_size, METH_O, NULL},
	 { "UnsignedIntVector_swap", _wrap_UnsignedIntVector_swap, METH_VARARGS, NULL},
	 { "UnsignedIntVector_begin", _wrap_UnsignedIntVector_begin, METH_O, NULL},
	 { "UnsignedIntVector_end", _wrap_UnsignedIntVector_end, METH_O, NULL},
	 { "UnsignedIntVector_rbegin", _wrap_UnsignedIntVector_rbegin, METH_O, NULL},
	 { "UnsignedIntVector_rend", _wrap_UnsignedIntVector_rend, METH_O, NULL},
	 { "UnsignedIntVector_clear", _wrap_UnsignedIntVector_clear, METH_O, NULL},
	 { "UnsignedIntVector_get_allocator", _wrap_UnsignedIntVector_get_allocator, METH_O, NULL},
	 { "UnsignedIntVector_pop_back", _wrap_UnsignedIntVector_pop_back, METH_O, NULL},
	 { "UnsignedIntVector_erase", _wrap_UnsignedIntVector_erase, METH_VARARGS, NULL},
	 { "new_UnsignedIntVector", _wrap_new_UnsignedIntVector, METH_VARARGS, NULL},
	 { "UnsignedIntVector_push_back", _wrap_UnsignedIntVector_push_back, METH_VARARGS, NULL},
	 { "UnsignedIntVector_front", _wrap_UnsignedIntVector_front, METH_O, NULL},
	 { "UnsignedIntVector_back", _wrap_UnsignedIntVector_back, METH_O, NULL},
	 { "UnsignedIntVector_assign", _wrap_UnsignedIntVector_assign, METH_VARARGS, NULL},
	 { "UnsignedIntVector_resize", _wrap_UnsignedIntVector_resize, METH_VARARGS, NULL},
	 { "UnsignedIntVector_insert", _wrap_UnsignedIntVector_insert, METH_VARARGS, NULL},
	 { "UnsignedIntVector_reserve", _wrap_UnsignedIntVector_reserve, METH_VARARGS, NULL},
	 { "UnsignedIntVector_capacity", _wrap_UnsignedIntVector_capacity, METH_O, NULL},
	 { "delete_UnsignedIntVector", _wrap_delete_UnsignedIntVector, METH_O, NULL},
	 { "UnsignedIntVector_swigregister", UnsignedIntVector_swigregister, METH_O, NULL},
	 { "UnsignedIntVector_swiginit", UnsignedIntVector_swiginit, METH_VARARGS, NULL},
	 { "DoubleVector_iterator", _wrap_DoubleVector_iterator, METH_O, NULL},
	 { "DoubleVector___nonzero__", _wrap_DoubleVector___nonzero__, METH_O, NULL},
	 { "DoubleVector___bool__", _wrap_DoubleVector___bool__, METH_O, NULL},
	 { "DoubleVector___len__", _wrap_DoubleVector___len__, METH_O, NULL},
	 { "DoubleVector___getslice__", _wrap_DoubleVector___getslice__, METH_VARARGS, NULL},
	 { "DoubleVector___setslice__", _wrap_DoubleVector___setslice__, METH_VARARGS, NULL},
	 { "DoubleVector___delslice__", _wrap_DoubleVector___delslice__, METH_VARARGS, NULL},
	 { "DoubleVector___delitem__", _wrap_DoubleVector___delitem__, METH_VARARGS, NULL},
	 { "DoubleVector___getitem__", _wrap_DoubleVector___getitem__, METH_VARARGS, NULL},
	 { "DoubleVector___setitem__", _wrap_DoubleVector___setitem__, METH_VARARGS, NULL},
	 { "DoubleVector_pop", _wrap_DoubleVector_pop, METH_O, NULL},
	 { "DoubleVector_append", _wrap_DoubleVector_append, METH_VARARGS, NULL},
	 { "DoubleVector_empty", _wrap_DoubleVector_empty, METH_O, NULL},
	 { "DoubleVector_size", _wrap_DoubleVector_size, METH_O, NULL},
	 { "DoubleVector_swap", _wrap_DoubleVector_swap, METH_VARARGS, NULL},
	 { "DoubleVector_begin", _wrap_DoubleVector_begin, METH_O, NULL},
	 { "DoubleVector_end", _wrap_DoubleVector_end, METH_O, NULL},
	 { "DoubleVector_rbegin", _wrap_DoubleVector_rbegin, METH_O, NULL},
	 { "DoubleVector_rend", _wrap_DoubleVector_rend, METH_O, NULL},
	 { "DoubleVector_clear", _wrap_DoubleVector_clear, METH_O, NULL},
	 { "DoubleVector_get_allocator", _wrap_DoubleVector_get_allocator, METH_O, NULL},
	 { "DoubleVector_pop_back", _wrap_DoubleVector_pop_back, METH_O, NULL},
	 { "DoubleVector_erase", _wrap_DoubleVector_erase, METH_VARARGS, NULL},
	 { "new_DoubleVector", _wrap_new_DoubleVector, METH_VARARGS, NULL},
	 { "DoubleVector_push_back", _wrap_DoubleVector_push_back, METH_VARARGS, NULL},
	 { "DoubleVector_front", _wrap_DoubleVector_front, METH_O, NULL},
	 { "DoubleVector_back", _wrap_DoubleVector_back, METH_O, NULL},
	 { "DoubleVector_assign", _wrap_DoubleVector_assign, METH_VARARGS, NULL},
	 { "DoubleVector_resize", _wrap_DoubleVector_resize, METH_VARARGS, NULL},
	 { "DoubleVector_insert", _wrap_DoubleVector_insert, METH_VARARGS, NULL},
	 { "DoubleVector_reserve", _wrap_DoubleVector_reserve, METH_VARARGS, NULL},
	 { "DoubleVector_capacity", _wrap_DoubleVector_capacity, METH_O, NULL},
	 { "delete_DoubleVector", _wrap_delete_DoubleVector, METH_O, NULL},
	 { "DoubleVector_swigregister", DoubleVector_swigregister, METH_O, NULL},
	 { "DoubleVector_swiginit", DoubleVector_swiginit, METH_VARARGS, NULL},
	 { "StrVector_iterator", _wrap_StrVector_iterator, METH_O, NULL},
	 { "StrVector___nonzero__", _wrap_StrVector___nonzero__, METH_O, NULL},
	 { "StrVector___bool__", _wrap_StrVector___bool__, METH_O, NULL},
	 { "StrVector___len__", _wrap_StrVector___len__, METH_O, NULL},
	 { "StrVector___getslice__", _wrap_StrVector___getslice__, METH_VARARGS, NULL},
	 { "StrVector___setslice__", _wrap_StrVector___setslice__, METH_VARARGS, NULL},
	 { "StrVector___delslice__", _wrap_StrVector___delslice__, METH_VARARGS, NULL},
	 { "StrVector___delitem__", _wrap_StrVector___delitem__, METH_VARARGS, NULL},
	 { "StrVector___getitem__", _wrap_StrVector___getitem__, METH_VARARGS, NULL},
	 { "StrVector___setitem__", _wrap_StrVector___setitem__, METH_VARARGS, NULL},
	 { "StrVector_pop", _wrap_StrVector_pop, METH_O, NULL},
	 { "StrVector_append", _wrap_StrVector_append, METH_VARARGS, NULL},
	 { "StrVector_empty", _wrap_StrVector_empty, METH_O, NULL},
	 { "StrVector_size", _wrap_StrVector_size, METH_O, NULL},
	 { "StrVector_swap", _wrap_StrVector_swap, METH_VARARGS, NULL},
	 { "StrVector_begin", _wrap_StrVector_begin, METH_O, NULL},
	 { "StrVector_end", _wrap_StrVector_end, METH_O, NULL},
	 { "StrVector_rbegin", _wrap_StrVector_rbegin, METH_O, NULL},
	 { "StrVector_rend", _wrap_StrVector_rend, METH_O, NULL},
	 { "StrVector_clear", _wrap_StrVector_clear, METH_O, NULL},
	 { "StrVector_get_allocator", _wrap_StrVector_get_allocator, METH_O, NULL},
	 { "StrVector_pop_back", _wrap_StrVector_pop_back, METH_O, NULL},
	 { "StrVector_erase", _wrap_StrVector_erase, METH_VARARGS, NULL},
	 { "new_StrVector", _wrap_new_StrVector, METH_VARARGS, NULL},
	 { "StrVector_push_back", _wrap_StrVector_push_back, METH_VARARGS, NULL},
	 { "StrVector_front", _wrap_StrVector_front, METH_O, NULL},
	 { "StrVector_back", _wrap_StrVector_back, METH_O, NULL},
	 { "StrVector_assign", _wrap_StrVector_assign, METH_VARARGS, NULL},
	 { "StrVector_resize", _wrap_StrVector_resize, METH_VARARGS, NULL},
	 { "StrVector_insert", _wrap_StrVector_insert, METH_VARARGS, NULL},
	 { "StrVector_reserve", _wrap_StrVector_reserve, METH_VARARGS, NULL},
	 { "StrVector_capacity", _wrap_StrVector_capacity, METH_O, NULL},
	 { "delete_StrVector", _wrap_delete_StrVector, METH_O, NULL},
	 { "StrVector_swigregister", StrVector_swigregister, METH_O, NULL},
	 { "StrVector_swiginit", StrVector_swiginit, METH_VARARGS, NULL},
	 { "BoolVector_iterator", _wrap_BoolVector_iterator, METH_O, NULL},
	 { "BoolVector___nonzero__", _wrap_BoolVector___nonzero__, METH_O, NULL},
	 { "BoolVector___bool__", _wrap_BoolVector___bool__, METH_O, NULL},
	 { "BoolVector___len__", _wrap_BoolVector___len__, METH_O, NULL},
	 { "BoolVector___getslice__", _wrap_BoolVector___getslice__, METH_VARARGS, NULL},
	 { "BoolVector___setslice__", _wrap_BoolVector___setslice__, METH_VARARGS, NULL},
	 { "BoolVector___delslice__", _wrap_BoolVector___delslice__, METH_VARARGS, NULL},
	 { "BoolVector___delitem__", _wrap_BoolVector___delitem__, METH_VARARGS, NULL},
	 { "BoolVector___getitem__", _wrap_BoolVector___getitem__, METH_VARARGS, NULL},
	 { "BoolVector___setitem__", _wrap_BoolVector___setitem__, METH_VARARGS, NULL},
	 { "BoolVector_pop", _wrap_BoolVector_pop, METH_O, NULL},
	 { "BoolVector_append", _wrap_BoolVector_append, METH_VARARGS, NULL},
	 { "BoolVector_empty", _wrap_BoolVector_empty, METH_O, NULL},
	 { "BoolVector_size", _wrap_BoolVector_size, METH_O, NULL},
	 { "BoolVector_swap", _wrap_BoolVector_swap, METH_VARARGS, NULL},
	 { "BoolVector_begin", _wrap_BoolVector_begin, METH_O, NULL},
	 { "BoolVector_end", _wrap_BoolVector_end, METH_O, NULL},
	 { "BoolVector_rbegin", _wrap_BoolVector_rbegin, METH_O, NULL},
	 { "BoolVector_rend", _wrap_BoolVector_rend, METH_O, NULL},
	 { "BoolVector_clear", _wrap_BoolVector_clear, METH_O, NULL},
	 { "BoolVector_get_allocator", _wrap_BoolVector_get_allocator, METH_O, NULL},
	 { "BoolVector_pop_back", _wrap_BoolVector_pop_back, METH_O, NULL},
	 { "BoolVector_erase", _wrap_BoolVector_erase, METH_VARARGS, NULL},
	 { "new_BoolVector", _wrap_new_BoolVector, METH_VARARGS, NULL},
	 { "BoolVector_push_back", _wrap_BoolVector_push_back, METH_VARARGS, NULL},
	 { "BoolVector_front", _wrap_BoolVector_front, METH_O, NULL},
	 { "BoolVector_back", _wrap_BoolVector_back, METH_O, NULL},
	 { "BoolVector_assign", _wrap_BoolVector_assign, METH_VARARGS, NULL},
	 { "BoolVector_resize", _wrap_BoolVector_resize, METH_VARARGS, NULL},
	 { "BoolVector_insert", _wrap_BoolVector_insert, METH_VARARGS, NULL},
	 { "BoolVector_reserve", _wrap_BoolVector_reserve, METH_VARARGS, NULL},
	 { "BoolVector_capacity", _wrap_BoolVector_capacity, METH_O, NULL},
	 { "delete_BoolVector", _wrap_delete_BoolVector, METH_O, NULL},
	 { "BoolVector_swigregister", BoolVector_swigregister, METH_O, NULL},
	 { "BoolVector_swiginit", BoolVector_swiginit, METH_VARARGS, NULL},
	 { "new_DoublePair", _wrap_new_DoublePair, METH_VARARGS, NULL},
	 { "DoublePair_first_set", _wrap_DoublePair_first_set, METH_VARARGS, NULL},
	 { "DoublePair_first_get", _wrap_DoublePair_first_get, METH_O, NULL},
	 { "DoublePair_second_set", _wrap_DoublePair_second_set, METH_VARARGS, NULL},
	 { "DoublePair_second_get", _wrap_DoublePair_second_get, METH_O, NULL},
	 { "delete_DoublePair", _wrap_delete_DoublePair, METH_O, NULL},
	 { "DoublePair_swigregister", DoublePair_swigregister, METH_O, NULL},
	 { "DoublePair_swiginit", DoublePair_swiginit, METH_VARARGS, NULL},
	 { "DoublePairVector_iterator", _wrap_DoublePairVector_iterator, METH_O, NULL},
	 { "DoublePairVector___nonzero__", _wrap_DoublePairVector___nonzero__, METH_O, NULL},
	 { "DoublePairVector___bool__", _wrap_DoublePairVector___bool__, METH_O, NULL},
	 { "DoublePairVector___len__", _wrap_DoublePairVector___len__, METH_O, NULL},
	 { "DoublePairVector___getslice__", _wrap_DoublePairVector___getslice__, METH_VARARGS, NULL},
	 { "DoublePairVector___setslice__", _wrap_DoublePairVector___setslice__, METH_VARARGS, NULL},
	 { "DoublePairVector___delslice__", _wrap_DoublePairVector___delslice__, METH_VARARGS, NULL},
	 { "DoublePairVector___delitem__", _wrap_DoublePairVector___delitem__, METH_VARARGS, NULL},
	 { "DoublePairVector___getitem__", _wrap_DoublePairVector___getitem__, METH_VARARGS, NULL},
	 { "DoublePairVector___setitem__", _wrap_DoublePairVector___setitem__, METH_VARARGS, NULL},
	 { "DoublePairVector_pop", _wrap_DoublePairVector_pop, METH_O, NULL},
	 { "DoublePairVector_append", _wrap_DoublePairVector_append, METH_VARARGS, NULL},
	 { "DoublePairVector_empty", _wrap_DoublePairVector_empty, METH_O, NULL},
	 { "DoublePairVector_size", _wrap_DoublePairVector_size, METH_O, NULL},
	 { "DoublePairVector_swap", _wrap_DoublePairVector_swap, METH_VARARGS, NULL},
	 { "DoublePairVector_begin", _wrap_DoublePairVector_begin, METH_O, NULL},
	 { "DoublePairVector_end", _wrap_DoublePairVector_end, METH_O, NULL},
	 { "DoublePairVector_rbegin", _wrap_DoublePairVector_rbegin, METH_O, NULL},
	 { "DoublePairVector_rend", _wrap_DoublePairVector_rend, METH_O, NULL},
	 { "DoublePairVector_clear", _wrap_DoublePairVector_clear, METH_O, NULL},
	 { "DoublePairVector_get_allocator", _wrap_DoublePairVector_get_allocator, METH_O, NULL},
	 { "DoublePairVector_pop_back", _wrap_DoublePairVector_pop_back, METH_O, NULL},
	 { "DoublePairVector_erase", _wrap_DoublePairVector_erase, METH_VARARGS, NULL},
	 { "new_DoublePairVector", _wrap_new_DoublePairVector, METH_VARARGS, NULL},
	 { "DoublePairVector_push_back", _wrap_DoublePairVector_push_back, METH_VARARGS, NULL},
	 { "DoublePairVector_front", _wrap_DoublePairVector_front, METH_O, NULL},
	 { "DoublePairVector_back", _wrap_DoublePairVector_back, METH_O, NULL},
	 { "DoublePairVector_assign", _wrap_DoublePairVector_assign, METH_VARARGS, NULL},
	 { "DoublePairVector_resize", _wrap_DoublePairVector_resize, METH_VARARGS, NULL},
	 { "DoublePairVector_insert", _wrap_DoublePairVector_insert, METH_VARARGS, NULL},
	 { "DoublePairVector_reserve", _wrap_DoublePairVector_reserve, METH_VARARGS, NULL},
	 { "DoublePairVector_capacity", _wrap_DoublePairVector_capacity, METH_O, NULL},
	 { "delete_DoublePairVector", _wrap_delete_DoublePairVector, METH_O, NULL},
	 { "DoublePairVector_swigregister", DoublePairVector_swigregister, METH_O, NULL},
	 { "DoublePairVector_swiginit", DoublePairVector_swiginit, METH_VARARGS, NULL},
	 { "new_PairDoubleVector", _wrap_new_PairDoubleVector, METH_VARARGS, NULL},
	 { "PairDoubleVector_first_set", _wrap_PairDoubleVector_first_set, METH_VARARGS, NULL},
	 { "PairDoubleVector_first_get", _wrap_PairDoubleVector_first_get, METH_O, NULL},
	 { "PairDoubleVector_second_set", _wrap_PairDoubleVector_second_set, METH_VARARGS, NULL},
	 { "PairDoubleVector_second_get", _wrap_PairDoubleVector_second_get, METH_O, NULL},
	 { "delete_PairDoubleVector", _wrap_delete_PairDoubleVector, METH_O, NULL},
	 { "PairDoubleVector_swigregister", PairDoubleVector_swigregister, METH_O, NULL},
	 { "PairDoubleVector_swiginit", PairDoubleVector_swiginit, METH_VARARGS, NULL},
	 { "new_NodePair", _wrap_new_NodePair, METH_VARARGS, NULL},
	 { "NodePair_first_set", _wrap_NodePair_first_set, METH_VARARGS, NULL},
	 { "NodePair_first_get", _wrap_NodePair_first_get, METH_O, NULL},
	 { "NodePair_second_set", _wrap_NodePair_second_set, METH_VARARGS, NULL},
	 { "NodePair_second_get", _wrap_NodePair_second_get, METH_O, NULL},
	 { "delete_NodePair", _wrap_delete_NodePair, METH_O, NULL},
	 { "NodePair_swigregister", NodePair_swigregister, METH_O, NULL},
	 { "NodePair_swiginit", NodePair_swiginit, METH_VARARGS, NULL},
	 { "NodeVector_iterator", _wrap_NodeVector_iterator, METH_O, NULL},
	 { "NodeVector___nonzero__", _wrap_NodeVector___nonzero__, METH_O, NULL},
	 { "NodeVector___bool__", _wrap_NodeVector___bool__, METH_O, NULL},
	 { "NodeVector___len__", _wrap_NodeVector___len__, METH_O, NULL},
	 { "NodeVector___getslice__", _wrap_NodeVector___getslice__, METH_VARARGS, NULL},
	 { "NodeVector___setslice__", _wrap_NodeVector___setslice__, METH_VARARGS, NULL},
	 { "NodeVector___delslice__", _wrap_NodeVector___delslice__, METH_VARARGS, NULL},
	 { "NodeVector___delitem__", _wrap_NodeVector___delitem__, METH_VARARGS, NULL},
	 { "NodeVector___getitem__", _wrap_NodeVector___getitem__, METH_VARARGS, NULL},
	 { "NodeVector___setitem__", _wrap_NodeVector___setitem__, METH_VARARGS, NULL},
	 { "NodeVector_pop", _wrap_NodeVector_pop, METH_O, NULL},
	 { "NodeVector_append", _wrap_NodeVector_append, METH_VARARGS, NULL},
	 { "NodeVector_empty", _wrap_NodeVector_empty, METH_O, NULL},
	 { "NodeVector_size", _wrap_NodeVector_size, METH_O, NULL},
	 { "NodeVector_swap", _wrap_NodeVector_swap, METH_VARARGS, NULL},
	 { "NodeVector_begin", _wrap_NodeVector_begin, METH_O, NULL},
	 { "NodeVector_end", _wrap_NodeVector_end, METH_O, NULL},
	 { "NodeVector_rbegin", _wrap_NodeVector_rbegin, METH_O, NULL},
	 { "NodeVector_rend", _wrap_NodeVector_rend, METH_O, NULL},
	 { "NodeVector_clear", _wrap_NodeVector_clear, METH_O, NULL},
	 { "NodeVector_get_allocator", _wrap_NodeVector_get_allocator, METH_O, NULL},
	 { "NodeVector_pop_back", _wrap_NodeVector_pop_back, METH_O, NULL},
	 { "NodeVector_erase", _wrap_NodeVector_erase, METH_VARARGS, NULL},
	 { "new_NodeVector", _wrap_new_NodeVector, METH_VARARGS, NULL},
	 { "NodeVector_push_back", _wrap_NodeVector_push_back, METH_VARARGS, NULL},
	 { "NodeVector_front", _wrap_NodeVector_front, METH_O, NULL},
	 { "NodeVector_back", _wrap_NodeVector_back, METH_O, NULL},
	 { "NodeVector_assign", _wrap_NodeVector_assign, METH_VARARGS, NULL},
	 { "NodeVector_resize", _wrap_NodeVector_resize, METH_VARARGS, NULL},
	 { "NodeVector_insert", _wrap_NodeVector_insert, METH_VARARGS, NULL},
	 { "NodeVector_reserve", _wrap_NodeVector_reserve, METH_VARARGS, NULL},
	 { "NodeVector_capacity", _wrap_NodeVector_capacity, METH_O, NULL},
	 { "delete_NodeVector", _wrap_delete_NodeVector, METH_O, NULL},
	 { "NodeVector_swigregister", NodeVector_swigregister, METH_O, NULL},
	 { "NodeVector_swiginit", NodeVector_swiginit, METH_VARARGS, NULL},
	 { "new_Exercise", _wrap_new_Exercise, METH_O, NULL},
	 { "Exercise_type", _wrap_Exercise_type, METH_O, NULL},
	 { "Exercise_date", _wrap_Exercise_date, METH_VARARGS, NULL},
	 { "Exercise_dateAt", _wrap_Exercise_dateAt, METH_VARARGS, NULL},
	 { "Exercise_dates", _wrap_Exercise_dates, METH_O, NULL},
	 { "Exercise_lastDate", _wrap_Exercise_lastDate, METH_O, NULL},
	 { "delete_Exercise", _wrap_delete_Exercise, METH_O, NULL},
	 { "Exercise_swigregister", Exercise_swigregister, METH_O, NULL},
	 { "Exercise_swiginit", Exercise_swiginit, METH_VARARGS, NULL},
	 { "new_EuropeanExercise", _wrap_new_EuropeanExercise, METH_O, NULL},
	 { "delete_EuropeanExercise", _wrap_delete_EuropeanExercise, METH_O, NULL},
	 { "EuropeanExercise_swigregister", EuropeanExercise_swigregister, METH_O, NULL},
	 { "EuropeanExercise_swiginit", EuropeanExercise_swiginit, METH_VARARGS, NULL},
	 { "new_AmericanExercise", _wrap_new_AmericanExercise, METH_VARARGS, NULL},
	 { "delete_AmericanExercise", _wrap_delete_AmericanExercise, METH_O, NULL},
	 { "AmericanExercise_swigregister", AmericanExercise_swigregister, METH_O, NULL},
	 { "AmericanExercise_swiginit", AmericanExercise_swiginit, METH_VARARGS, NULL},
	 { "new_BermudanExercise", _wrap_new_BermudanExercise, METH_VARARGS, NULL},
	 { "delete_BermudanExercise", _wrap_delete_BermudanExercise, METH_O, NULL},
	 { "BermudanExercise_swigregister", BermudanExercise_swigregister, METH_O, NULL},
	 { "BermudanExercise_swiginit", BermudanExercise_swiginit, METH_VARARGS, NULL},
	 { "new_RebatedExercise", _wrap_new_RebatedExercise, METH_VARARGS, NULL},
	 { "delete_RebatedExercise", _wrap_delete_RebatedExercise, METH_O, NULL},
	 { "RebatedExercise_swigregister", RebatedExercise_swigregister, METH_O, NULL},
	 { "RebatedExercise_swiginit", RebatedExercise_swiginit, METH_VARARGS, NULL},
	 { "new_SwingExercise", _wrap_new_SwingExercise, METH_O, NULL},
	 { "delete_SwingExercise", _wrap_delete_SwingExercise, METH_O, NULL},
	 { "SwingExercise_swigregister", SwingExercise_swigregister, METH_O, NULL},
	 { "SwingExercise_swiginit", SwingExercise_swiginit, METH_VARARGS, NULL},
	 { "new_Observable", _wrap_new_Observable, METH_NOARGS, NULL},
	 { "delete_Observable", _wrap_delete_Observable, METH_O, NULL},
	 { "Observable_swigregister", Observable_swigregister, METH_O, NULL},
	 { "Observable_swiginit", Observable_swiginit, METH_VARARGS, NULL},
	 { "new_Observer", _wrap_new_Observer, METH_O, NULL},
	 { "Observer__registerWith", _wrap_Observer__registerWith, METH_VARARGS, NULL},
	 { "Observer__unregisterWith", _wrap_Observer__unregisterWith, METH_VARARGS, NULL},
	 { "delete_Observer", _wrap_delete_Observer, METH_O, NULL},
	 { "Observer_swigregister", Observer_swigregister, METH_O, NULL},
	 { "Observer_swiginit", Observer_swiginit, METH_VARARGS, NULL},
	 { "new_Array", _wrap_new_Array, METH_VARARGS, NULL},
	 { "Array___len__", _wrap_Array___len__, METH_O, NULL},
	 { "Array___str__", _wrap_Array___str__, METH_O, NULL},
	 { "Array___add__", _wrap_Array___add__, METH_VARARGS, NULL},
	 { "Array___sub__", _wrap_Array___sub__, METH_VARARGS, NULL},
	 { "Array___mul__", _wrap_Array___mul__, METH_VARARGS, NULL},
	 { "Array___div__", _wrap_Array___div__, METH_VARARGS, NULL},
	 { "Array___rmul__", _wrap_Array___rmul__, METH_VARARGS, NULL},
	 { "Array___getslice__", _wrap_Array___getslice__, METH_VARARGS, NULL},
	 { "Array___setslice__", _wrap_Array___setslice__, METH_VARARGS, NULL},
	 { "Array___nonzero__", _wrap_Array___nonzero__, METH_O, NULL},
	 { "Array___bool__", _wrap_Array___bool__, METH_O, NULL},
	 { "Array___getitem__", _wrap_Array___getitem__, METH_VARARGS, NULL},
	 { "Array___setitem__", _wrap_Array___setitem__, METH_VARARGS, NULL},
	 { "delete_Array", _wrap_delete_Array, METH_O, NULL},
	 { "Array_swigregister", Array_swigregister, METH_O, NULL},
	 { "Array_swiginit", Array_swiginit, METH_VARARGS, NULL},
	 { "DefaultLexicographicalViewColumn___getitem__", _wrap_DefaultLexicographicalViewColumn___getitem__, METH_VARARGS, NULL},
	 { "DefaultLexicographicalViewColumn___setitem__", _wrap_DefaultLexicographicalViewColumn___setitem__, METH_VARARGS, NULL},
	 { "delete_DefaultLexicographicalViewColumn", _wrap_delete_DefaultLexicographicalViewColumn, METH_O, NULL},
	 { "DefaultLexicographicalViewColumn_swigregister", DefaultLexicographicalViewColumn_swigregister, METH_O, NULL},
	 { "LexicographicalView_xSize", _wrap_LexicographicalView_xSize, METH_O, NULL},
	 { "LexicographicalView_ySize", _wrap_LexicographicalView_ySize, METH_O, NULL},
	 { "new_LexicographicalView", _wrap_new_LexicographicalView, METH_VARARGS, NULL},
	 { "LexicographicalView___str__", _wrap_LexicographicalView___str__, METH_O, NULL},
	 { "LexicographicalView___getitem__", _wrap_LexicographicalView___getitem__, METH_VARARGS, NULL},
	 { "delete_LexicographicalView", _wrap_delete_LexicographicalView, METH_O, NULL},
	 { "LexicographicalView_swigregister", LexicographicalView_swigregister, METH_O, NULL},
	 { "LexicographicalView_swiginit", LexicographicalView_swiginit, METH_VARARGS, NULL},
	 { "MatrixRow___getitem__", _wrap_MatrixRow___getitem__, METH_VARARGS, NULL},
	 { "MatrixRow___setitem__", _wrap_MatrixRow___setitem__, METH_VARARGS, NULL},
	 { "delete_MatrixRow", _wrap_delete_MatrixRow, METH_O, NULL},
	 { "MatrixRow_swigregister", MatrixRow_swigregister, METH_O, NULL},
	 { "new_Matrix", _wrap_new_Matrix, METH_VARARGS, NULL},
	 { "Matrix_rows", _wrap_Matrix_rows, METH_O, NULL},
	 { "Matrix_columns", _wrap_Matrix_columns, METH_O, NULL},
	 { "Matrix___str__", _wrap_Matrix___str__, METH_O, NULL},
	 { "Matrix___add__", _wrap_Matrix___add__, METH_VARARGS, NULL},
	 { "Matrix___sub__", _wrap_Matrix___sub__, METH_VARARGS, NULL},
	 { "Matrix___mul__", _wrap_Matrix___mul__, METH_VARARGS, NULL},
	 { "Matrix___div__", _wrap_Matrix___div__, METH_VARARGS, NULL},
	 { "Matrix___getitem__", _wrap_Matrix___getitem__, METH_VARARGS, NULL},
	 { "Matrix___rmul__", _wrap_Matrix___rmul__, METH_VARARGS, NULL},
	 { "delete_Matrix", _wrap_delete_Matrix, METH_O, NULL},
	 { "Matrix_swigregister", Matrix_swigregister, METH_O, NULL},
	 { "Matrix_swiginit", Matrix_swiginit, METH_VARARGS, NULL},
	 { "new_SalvagingAlgorithm", _wrap_new_SalvagingAlgorithm, METH_NOARGS, NULL},
	 { "delete_SalvagingAlgorithm", _wrap_delete_SalvagingAlgorithm, METH_O, NULL},
	 { "SalvagingAlgorithm_swigregister", SalvagingAlgorithm_swigregister, METH_O, NULL},
	 { "SalvagingAlgorithm_swiginit", SalvagingAlgorithm_swiginit, METH_VARARGS, NULL},
	 { "inverse", _wrap_inverse, METH_O, NULL},
	 { "transpose", _wrap_transpose, METH_O, NULL},
	 { "outerProduct", _wrap_outerProduct, METH_VARARGS, NULL},
	 { "pseudoSqrt", _wrap_pseudoSqrt, METH_VARARGS, NULL},
	 { "new_SVD", _wrap_new_SVD, METH_O, NULL},
	 { "SVD_U", _wrap_SVD_U, METH_O, NULL},
	 { "SVD_V", _wrap_SVD_V, METH_O, NULL},
	 { "SVD_S", _wrap_SVD_S, METH_O, NULL},
	 { "SVD_singularValues", _wrap_SVD_singularValues, METH_O, NULL},
	 { "delete_SVD", _wrap_delete_SVD, METH_O, NULL},
	 { "SVD_swigregister", SVD_swigregister, METH_O, NULL},
	 { "SVD_swiginit", SVD_swiginit, METH_VARARGS, NULL},
	 { "new_MatrixMultiplicationProxy", _wrap_new_MatrixMultiplicationProxy, METH_O, NULL},
	 { "MatrixMultiplicationProxy___call__", _wrap_MatrixMultiplicationProxy___call__, METH_VARARGS, NULL},
	 { "delete_MatrixMultiplicationProxy", _wrap_delete_MatrixMultiplicationProxy, METH_O, NULL},
	 { "MatrixMultiplicationProxy_swigregister", MatrixMultiplicationProxy_swigregister, METH_O, NULL},
	 { "MatrixMultiplicationProxy_swiginit", MatrixMultiplicationProxy_swiginit, METH_VARARGS, NULL},
	 { "BiCGstab_solve", _wrap_BiCGstab_solve, METH_VARARGS, NULL},
	 { "new_BiCGstab", _wrap_new_BiCGstab, METH_VARARGS, NULL},
	 { "delete_BiCGstab", _wrap_delete_BiCGstab, METH_O, NULL},
	 { "BiCGstab_swigregister", BiCGstab_swigregister, METH_O, NULL},
	 { "BiCGstab_swiginit", BiCGstab_swiginit, METH_VARARGS, NULL},
	 { "GMRES_solve", _wrap_GMRES_solve, METH_VARARGS, NULL},
	 { "GMRES_solveWithRestart", _wrap_GMRES_solveWithRestart, METH_VARARGS, NULL},
	 { "new_GMRES", _wrap_new_GMRES, METH_VARARGS, NULL},
	 { "delete_GMRES", _wrap_delete_GMRES, METH_O, NULL},
	 { "GMRES_swigregister", GMRES_swigregister, METH_O, NULL},
	 { "GMRES_swiginit", GMRES_swiginit, METH_VARARGS, NULL},
	 { "close", _wrap_close, METH_VARARGS, NULL},
	 { "close_enough", _wrap_close_enough, METH_VARARGS, NULL},
	 { "Quote_value", _wrap_Quote_value, METH_O, NULL},
	 { "Quote_isValid", _wrap_Quote_isValid, METH_O, NULL},
	 { "delete_Quote", _wrap_delete_Quote, METH_O, NULL},
	 { "Quote_swigregister", Quote_swigregister, METH_O, NULL},
	 { "new_QuoteHandle", _wrap_new_QuoteHandle, METH_VARARGS, NULL},
	 { "QuoteHandle___deref__", _wrap_QuoteHandle___deref__, METH_O, NULL},
	 { "QuoteHandle_currentLink", _wrap_QuoteHandle_currentLink, METH_O, NULL},
	 { "QuoteHandle___nonzero__", _wrap_QuoteHandle___nonzero__, METH_O, NULL},
	 { "QuoteHandle___bool__", _wrap_QuoteHandle___bool__, METH_O, NULL},
	 { "QuoteHandle_asObservable", _wrap_QuoteHandle_asObservable, METH_O, NULL},
	 { "delete_QuoteHandle", _wrap_delete_QuoteHandle, METH_O, NULL},
	 { "QuoteHandle_value", _wrap_QuoteHandle_value, METH_O, NULL},
	 { "QuoteHandle_isValid", _wrap_QuoteHandle_isValid, METH_O, NULL},
	 { "QuoteHandle_swigregister", QuoteHandle_swigregister, METH_O, NULL},
	 { "QuoteHandle_swiginit", QuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableQuoteHandle", _wrap_new_RelinkableQuoteHandle, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandle_linkTo", _wrap_RelinkableQuoteHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandle_reset", _wrap_RelinkableQuoteHandle_reset, METH_O, NULL},
	 { "delete_RelinkableQuoteHandle", _wrap_delete_RelinkableQuoteHandle, METH_O, NULL},
	 { "RelinkableQuoteHandle_swigregister", RelinkableQuoteHandle_swigregister, METH_O, NULL},
	 { "RelinkableQuoteHandle_swiginit", RelinkableQuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleQuote", _wrap_new_SimpleQuote, METH_O, NULL},
	 { "SimpleQuote_setValue", _wrap_SimpleQuote_setValue, METH_VARARGS, NULL},
	 { "delete_SimpleQuote", _wrap_delete_SimpleQuote, METH_O, NULL},
	 { "SimpleQuote_swigregister", SimpleQuote_swigregister, METH_O, NULL},
	 { "SimpleQuote_swiginit", SimpleQuote_swiginit, METH_VARARGS, NULL},
	 { "new_DerivedQuote", _wrap_new_DerivedQuote, METH_VARARGS, NULL},
	 { "delete_DerivedQuote", _wrap_delete_DerivedQuote, METH_O, NULL},
	 { "DerivedQuote_swigregister", DerivedQuote_swigregister, METH_O, NULL},
	 { "DerivedQuote_swiginit", DerivedQuote_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeQuote", _wrap_new_CompositeQuote, METH_VARARGS, NULL},
	 { "delete_CompositeQuote", _wrap_delete_CompositeQuote, METH_O, NULL},
	 { "CompositeQuote_swigregister", CompositeQuote_swigregister, METH_O, NULL},
	 { "CompositeQuote_swiginit", CompositeQuote_swiginit, METH_VARARGS, NULL},
	 { "QuoteVector_iterator", _wrap_QuoteVector_iterator, METH_O, NULL},
	 { "QuoteVector___nonzero__", _wrap_QuoteVector___nonzero__, METH_O, NULL},
	 { "QuoteVector___bool__", _wrap_QuoteVector___bool__, METH_O, NULL},
	 { "QuoteVector___len__", _wrap_QuoteVector___len__, METH_O, NULL},
	 { "QuoteVector___getslice__", _wrap_QuoteVector___getslice__, METH_VARARGS, NULL},
	 { "QuoteVector___setslice__", _wrap_QuoteVector___setslice__, METH_VARARGS, NULL},
	 { "QuoteVector___delslice__", _wrap_QuoteVector___delslice__, METH_VARARGS, NULL},
	 { "QuoteVector___delitem__", _wrap_QuoteVector___delitem__, METH_VARARGS, NULL},
	 { "QuoteVector___getitem__", _wrap_QuoteVector___getitem__, METH_VARARGS, NULL},
	 { "QuoteVector___setitem__", _wrap_QuoteVector___setitem__, METH_VARARGS, NULL},
	 { "QuoteVector_pop", _wrap_QuoteVector_pop, METH_O, NULL},
	 { "QuoteVector_append", _wrap_QuoteVector_append, METH_VARARGS, NULL},
	 { "QuoteVector_empty", _wrap_QuoteVector_empty, METH_O, NULL},
	 { "QuoteVector_size", _wrap_QuoteVector_size, METH_O, NULL},
	 { "QuoteVector_swap", _wrap_QuoteVector_swap, METH_VARARGS, NULL},
	 { "QuoteVector_begin", _wrap_QuoteVector_begin, METH_O, NULL},
	 { "QuoteVector_end", _wrap_QuoteVector_end, METH_O, NULL},
	 { "QuoteVector_rbegin", _wrap_QuoteVector_rbegin, METH_O, NULL},
	 { "QuoteVector_rend", _wrap_QuoteVector_rend, METH_O, NULL},
	 { "QuoteVector_clear", _wrap_QuoteVector_clear, METH_O, NULL},
	 { "QuoteVector_get_allocator", _wrap_QuoteVector_get_allocator, METH_O, NULL},
	 { "QuoteVector_pop_back", _wrap_QuoteVector_pop_back, METH_O, NULL},
	 { "QuoteVector_erase", _wrap_QuoteVector_erase, METH_VARARGS, NULL},
	 { "new_QuoteVector", _wrap_new_QuoteVector, METH_VARARGS, NULL},
	 { "QuoteVector_push_back", _wrap_QuoteVector_push_back, METH_VARARGS, NULL},
	 { "QuoteVector_front", _wrap_QuoteVector_front, METH_O, NULL},
	 { "QuoteVector_back", _wrap_QuoteVector_back, METH_O, NULL},
	 { "QuoteVector_assign", _wrap_QuoteVector_assign, METH_VARARGS, NULL},
	 { "QuoteVector_resize", _wrap_QuoteVector_resize, METH_VARARGS, NULL},
	 { "QuoteVector_insert", _wrap_QuoteVector_insert, METH_VARARGS, NULL},
	 { "QuoteVector_reserve", _wrap_QuoteVector_reserve, METH_VARARGS, NULL},
	 { "QuoteVector_capacity", _wrap_QuoteVector_capacity, METH_O, NULL},
	 { "delete_QuoteVector", _wrap_delete_QuoteVector, METH_O, NULL},
	 { "QuoteVector_swigregister", QuoteVector_swigregister, METH_O, NULL},
	 { "QuoteVector_swiginit", QuoteVector_swiginit, METH_VARARGS, NULL},
	 { "QuoteVectorVector_iterator", _wrap_QuoteVectorVector_iterator, METH_O, NULL},
	 { "QuoteVectorVector___nonzero__", _wrap_QuoteVectorVector___nonzero__, METH_O, NULL},
	 { "QuoteVectorVector___bool__", _wrap_QuoteVectorVector___bool__, METH_O, NULL},
	 { "QuoteVectorVector___len__", _wrap_QuoteVectorVector___len__, METH_O, NULL},
	 { "QuoteVectorVector___getslice__", _wrap_QuoteVectorVector___getslice__, METH_VARARGS, NULL},
	 { "QuoteVectorVector___setslice__", _wrap_QuoteVectorVector___setslice__, METH_VARARGS, NULL},
	 { "QuoteVectorVector___delslice__", _wrap_QuoteVectorVector___delslice__, METH_VARARGS, NULL},
	 { "QuoteVectorVector___delitem__", _wrap_QuoteVectorVector___delitem__, METH_VARARGS, NULL},
	 { "QuoteVectorVector___getitem__", _wrap_QuoteVectorVector___getitem__, METH_VARARGS, NULL},
	 { "QuoteVectorVector___setitem__", _wrap_QuoteVectorVector___setitem__, METH_VARARGS, NULL},
	 { "QuoteVectorVector_pop", _wrap_QuoteVectorVector_pop, METH_O, NULL},
	 { "QuoteVectorVector_append", _wrap_QuoteVectorVector_append, METH_VARARGS, NULL},
	 { "QuoteVectorVector_empty", _wrap_QuoteVectorVector_empty, METH_O, NULL},
	 { "QuoteVectorVector_size", _wrap_QuoteVectorVector_size, METH_O, NULL},
	 { "QuoteVectorVector_swap", _wrap_QuoteVectorVector_swap, METH_VARARGS, NULL},
	 { "QuoteVectorVector_begin", _wrap_QuoteVectorVector_begin, METH_O, NULL},
	 { "QuoteVectorVector_end", _wrap_QuoteVectorVector_end, METH_O, NULL},
	 { "QuoteVectorVector_rbegin", _wrap_QuoteVectorVector_rbegin, METH_O, NULL},
	 { "QuoteVectorVector_rend", _wrap_QuoteVectorVector_rend, METH_O, NULL},
	 { "QuoteVectorVector_clear", _wrap_QuoteVectorVector_clear, METH_O, NULL},
	 { "QuoteVectorVector_get_allocator", _wrap_QuoteVectorVector_get_allocator, METH_O, NULL},
	 { "QuoteVectorVector_pop_back", _wrap_QuoteVectorVector_pop_back, METH_O, NULL},
	 { "QuoteVectorVector_erase", _wrap_QuoteVectorVector_erase, METH_VARARGS, NULL},
	 { "new_QuoteVectorVector", _wrap_new_QuoteVectorVector, METH_VARARGS, NULL},
	 { "QuoteVectorVector_push_back", _wrap_QuoteVectorVector_push_back, METH_VARARGS, NULL},
	 { "QuoteVectorVector_front", _wrap_QuoteVectorVector_front, METH_O, NULL},
	 { "QuoteVectorVector_back", _wrap_QuoteVectorVector_back, METH_O, NULL},
	 { "QuoteVectorVector_assign", _wrap_QuoteVectorVector_assign, METH_VARARGS, NULL},
	 { "QuoteVectorVector_resize", _wrap_QuoteVectorVector_resize, METH_VARARGS, NULL},
	 { "QuoteVectorVector_insert", _wrap_QuoteVectorVector_insert, METH_VARARGS, NULL},
	 { "QuoteVectorVector_reserve", _wrap_QuoteVectorVector_reserve, METH_VARARGS, NULL},
	 { "QuoteVectorVector_capacity", _wrap_QuoteVectorVector_capacity, METH_O, NULL},
	 { "delete_QuoteVectorVector", _wrap_delete_QuoteVectorVector, METH_O, NULL},
	 { "QuoteVectorVector_swigregister", QuoteVectorVector_swigregister, METH_O, NULL},
	 { "QuoteVectorVector_swiginit", QuoteVectorVector_swiginit, METH_VARARGS, NULL},
	 { "QuoteHandleVector_iterator", _wrap_QuoteHandleVector_iterator, METH_O, NULL},
	 { "QuoteHandleVector___nonzero__", _wrap_QuoteHandleVector___nonzero__, METH_O, NULL},
	 { "QuoteHandleVector___bool__", _wrap_QuoteHandleVector___bool__, METH_O, NULL},
	 { "QuoteHandleVector___len__", _wrap_QuoteHandleVector___len__, METH_O, NULL},
	 { "QuoteHandleVector___getslice__", _wrap_QuoteHandleVector___getslice__, METH_VARARGS, NULL},
	 { "QuoteHandleVector___setslice__", _wrap_QuoteHandleVector___setslice__, METH_VARARGS, NULL},
	 { "QuoteHandleVector___delslice__", _wrap_QuoteHandleVector___delslice__, METH_VARARGS, NULL},
	 { "QuoteHandleVector___delitem__", _wrap_QuoteHandleVector___delitem__, METH_VARARGS, NULL},
	 { "QuoteHandleVector___getitem__", _wrap_QuoteHandleVector___getitem__, METH_VARARGS, NULL},
	 { "QuoteHandleVector___setitem__", _wrap_QuoteHandleVector___setitem__, METH_VARARGS, NULL},
	 { "QuoteHandleVector_pop", _wrap_QuoteHandleVector_pop, METH_O, NULL},
	 { "QuoteHandleVector_append", _wrap_QuoteHandleVector_append, METH_VARARGS, NULL},
	 { "QuoteHandleVector_empty", _wrap_QuoteHandleVector_empty, METH_O, NULL},
	 { "QuoteHandleVector_size", _wrap_QuoteHandleVector_size, METH_O, NULL},
	 { "QuoteHandleVector_swap", _wrap_QuoteHandleVector_swap, METH_VARARGS, NULL},
	 { "QuoteHandleVector_begin", _wrap_QuoteHandleVector_begin, METH_O, NULL},
	 { "QuoteHandleVector_end", _wrap_QuoteHandleVector_end, METH_O, NULL},
	 { "QuoteHandleVector_rbegin", _wrap_QuoteHandleVector_rbegin, METH_O, NULL},
	 { "QuoteHandleVector_rend", _wrap_QuoteHandleVector_rend, METH_O, NULL},
	 { "QuoteHandleVector_clear", _wrap_QuoteHandleVector_clear, METH_O, NULL},
	 { "QuoteHandleVector_get_allocator", _wrap_QuoteHandleVector_get_allocator, METH_O, NULL},
	 { "QuoteHandleVector_pop_back", _wrap_QuoteHandleVector_pop_back, METH_O, NULL},
	 { "QuoteHandleVector_erase", _wrap_QuoteHandleVector_erase, METH_VARARGS, NULL},
	 { "new_QuoteHandleVector", _wrap_new_QuoteHandleVector, METH_VARARGS, NULL},
	 { "QuoteHandleVector_push_back", _wrap_QuoteHandleVector_push_back, METH_VARARGS, NULL},
	 { "QuoteHandleVector_front", _wrap_QuoteHandleVector_front, METH_O, NULL},
	 { "QuoteHandleVector_back", _wrap_QuoteHandleVector_back, METH_O, NULL},
	 { "QuoteHandleVector_assign", _wrap_QuoteHandleVector_assign, METH_VARARGS, NULL},
	 { "QuoteHandleVector_resize", _wrap_QuoteHandleVector_resize, METH_VARARGS, NULL},
	 { "QuoteHandleVector_insert", _wrap_QuoteHandleVector_insert, METH_VARARGS, NULL},
	 { "QuoteHandleVector_reserve", _wrap_QuoteHandleVector_reserve, METH_VARARGS, NULL},
	 { "QuoteHandleVector_capacity", _wrap_QuoteHandleVector_capacity, METH_O, NULL},
	 { "delete_QuoteHandleVector", _wrap_delete_QuoteHandleVector, METH_O, NULL},
	 { "QuoteHandleVector_swigregister", QuoteHandleVector_swigregister, METH_O, NULL},
	 { "QuoteHandleVector_swiginit", QuoteHandleVector_swiginit, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_iterator", _wrap_QuoteHandleVectorVector_iterator, METH_O, NULL},
	 { "QuoteHandleVectorVector___nonzero__", _wrap_QuoteHandleVectorVector___nonzero__, METH_O, NULL},
	 { "QuoteHandleVectorVector___bool__", _wrap_QuoteHandleVectorVector___bool__, METH_O, NULL},
	 { "QuoteHandleVectorVector___len__", _wrap_QuoteHandleVectorVector___len__, METH_O, NULL},
	 { "QuoteHandleVectorVector___getslice__", _wrap_QuoteHandleVectorVector___getslice__, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector___setslice__", _wrap_QuoteHandleVectorVector___setslice__, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector___delslice__", _wrap_QuoteHandleVectorVector___delslice__, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector___delitem__", _wrap_QuoteHandleVectorVector___delitem__, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector___getitem__", _wrap_QuoteHandleVectorVector___getitem__, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector___setitem__", _wrap_QuoteHandleVectorVector___setitem__, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_pop", _wrap_QuoteHandleVectorVector_pop, METH_O, NULL},
	 { "QuoteHandleVectorVector_append", _wrap_QuoteHandleVectorVector_append, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_empty", _wrap_QuoteHandleVectorVector_empty, METH_O, NULL},
	 { "QuoteHandleVectorVector_size", _wrap_QuoteHandleVectorVector_size, METH_O, NULL},
	 { "QuoteHandleVectorVector_swap", _wrap_QuoteHandleVectorVector_swap, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_begin", _wrap_QuoteHandleVectorVector_begin, METH_O, NULL},
	 { "QuoteHandleVectorVector_end", _wrap_QuoteHandleVectorVector_end, METH_O, NULL},
	 { "QuoteHandleVectorVector_rbegin", _wrap_QuoteHandleVectorVector_rbegin, METH_O, NULL},
	 { "QuoteHandleVectorVector_rend", _wrap_QuoteHandleVectorVector_rend, METH_O, NULL},
	 { "QuoteHandleVectorVector_clear", _wrap_QuoteHandleVectorVector_clear, METH_O, NULL},
	 { "QuoteHandleVectorVector_get_allocator", _wrap_QuoteHandleVectorVector_get_allocator, METH_O, NULL},
	 { "QuoteHandleVectorVector_pop_back", _wrap_QuoteHandleVectorVector_pop_back, METH_O, NULL},
	 { "QuoteHandleVectorVector_erase", _wrap_QuoteHandleVectorVector_erase, METH_VARARGS, NULL},
	 { "new_QuoteHandleVectorVector", _wrap_new_QuoteHandleVectorVector, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_push_back", _wrap_QuoteHandleVectorVector_push_back, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_front", _wrap_QuoteHandleVectorVector_front, METH_O, NULL},
	 { "QuoteHandleVectorVector_back", _wrap_QuoteHandleVectorVector_back, METH_O, NULL},
	 { "QuoteHandleVectorVector_assign", _wrap_QuoteHandleVectorVector_assign, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_resize", _wrap_QuoteHandleVectorVector_resize, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_insert", _wrap_QuoteHandleVectorVector_insert, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_reserve", _wrap_QuoteHandleVectorVector_reserve, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_capacity", _wrap_QuoteHandleVectorVector_capacity, METH_O, NULL},
	 { "delete_QuoteHandleVectorVector", _wrap_delete_QuoteHandleVectorVector, METH_O, NULL},
	 { "QuoteHandleVectorVector_swigregister", QuoteHandleVectorVector_swigregister, METH_O, NULL},
	 { "QuoteHandleVectorVector_swiginit", QuoteHandleVectorVector_swiginit, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_iterator", _wrap_RelinkableQuoteHandleVector_iterator, METH_O, NULL},
	 { "RelinkableQuoteHandleVector___nonzero__", _wrap_RelinkableQuoteHandleVector___nonzero__, METH_O, NULL},
	 { "RelinkableQuoteHandleVector___bool__", _wrap_RelinkableQuoteHandleVector___bool__, METH_O, NULL},
	 { "RelinkableQuoteHandleVector___len__", _wrap_RelinkableQuoteHandleVector___len__, METH_O, NULL},
	 { "RelinkableQuoteHandleVector___getslice__", _wrap_RelinkableQuoteHandleVector___getslice__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector___setslice__", _wrap_RelinkableQuoteHandleVector___setslice__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector___delslice__", _wrap_RelinkableQuoteHandleVector___delslice__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector___delitem__", _wrap_RelinkableQuoteHandleVector___delitem__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector___getitem__", _wrap_RelinkableQuoteHandleVector___getitem__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector___setitem__", _wrap_RelinkableQuoteHandleVector___setitem__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_pop", _wrap_RelinkableQuoteHandleVector_pop, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_append", _wrap_RelinkableQuoteHandleVector_append, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_empty", _wrap_RelinkableQuoteHandleVector_empty, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_size", _wrap_RelinkableQuoteHandleVector_size, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_swap", _wrap_RelinkableQuoteHandleVector_swap, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_begin", _wrap_RelinkableQuoteHandleVector_begin, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_end", _wrap_RelinkableQuoteHandleVector_end, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_rbegin", _wrap_RelinkableQuoteHandleVector_rbegin, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_rend", _wrap_RelinkableQuoteHandleVector_rend, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_clear", _wrap_RelinkableQuoteHandleVector_clear, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_get_allocator", _wrap_RelinkableQuoteHandleVector_get_allocator, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_pop_back", _wrap_RelinkableQuoteHandleVector_pop_back, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_erase", _wrap_RelinkableQuoteHandleVector_erase, METH_VARARGS, NULL},
	 { "new_RelinkableQuoteHandleVector", _wrap_new_RelinkableQuoteHandleVector, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_push_back", _wrap_RelinkableQuoteHandleVector_push_back, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_front", _wrap_RelinkableQuoteHandleVector_front, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_back", _wrap_RelinkableQuoteHandleVector_back, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_assign", _wrap_RelinkableQuoteHandleVector_assign, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_resize", _wrap_RelinkableQuoteHandleVector_resize, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_insert", _wrap_RelinkableQuoteHandleVector_insert, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_reserve", _wrap_RelinkableQuoteHandleVector_reserve, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_capacity", _wrap_RelinkableQuoteHandleVector_capacity, METH_O, NULL},
	 { "delete_RelinkableQuoteHandleVector", _wrap_delete_RelinkableQuoteHandleVector, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_swigregister", RelinkableQuoteHandleVector_swigregister, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_swiginit", RelinkableQuoteHandleVector_swiginit, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_iterator", _wrap_RelinkableQuoteHandleVectorVector_iterator, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector___nonzero__", _wrap_RelinkableQuoteHandleVectorVector___nonzero__, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector___bool__", _wrap_RelinkableQuoteHandleVectorVector___bool__, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector___len__", _wrap_RelinkableQuoteHandleVectorVector___len__, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector___getslice__", _wrap_RelinkableQuoteHandleVectorVector___getslice__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector___setslice__", _wrap_RelinkableQuoteHandleVectorVector___setslice__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector___delslice__", _wrap_RelinkableQuoteHandleVectorVector___delslice__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector___delitem__", _wrap_RelinkableQuoteHandleVectorVector___delitem__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector___getitem__", _wrap_RelinkableQuoteHandleVectorVector___getitem__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector___setitem__", _wrap_RelinkableQuoteHandleVectorVector___setitem__, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_pop", _wrap_RelinkableQuoteHandleVectorVector_pop, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_append", _wrap_RelinkableQuoteHandleVectorVector_append, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_empty", _wrap_RelinkableQuoteHandleVectorVector_empty, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_size", _wrap_RelinkableQuoteHandleVectorVector_size, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_swap", _wrap_RelinkableQuoteHandleVectorVector_swap, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_begin", _wrap_RelinkableQuoteHandleVectorVector_begin, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_end", _wrap_RelinkableQuoteHandleVectorVector_end, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_rbegin", _wrap_RelinkableQuoteHandleVectorVector_rbegin, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_rend", _wrap_RelinkableQuoteHandleVectorVector_rend, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_clear", _wrap_RelinkableQuoteHandleVectorVector_clear, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_get_allocator", _wrap_RelinkableQuoteHandleVectorVector_get_allocator, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_pop_back", _wrap_RelinkableQuoteHandleVectorVector_pop_back, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_erase", _wrap_RelinkableQuoteHandleVectorVector_erase, METH_VARARGS, NULL},
	 { "new_RelinkableQuoteHandleVectorVector", _wrap_new_RelinkableQuoteHandleVectorVector, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_push_back", _wrap_RelinkableQuoteHandleVectorVector_push_back, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_front", _wrap_RelinkableQuoteHandleVectorVector_front, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_back", _wrap_RelinkableQuoteHandleVectorVector_back, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_assign", _wrap_RelinkableQuoteHandleVectorVector_assign, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_resize", _wrap_RelinkableQuoteHandleVectorVector_resize, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_insert", _wrap_RelinkableQuoteHandleVectorVector_insert, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_reserve", _wrap_RelinkableQuoteHandleVectorVector_reserve, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_capacity", _wrap_RelinkableQuoteHandleVectorVector_capacity, METH_O, NULL},
	 { "delete_RelinkableQuoteHandleVectorVector", _wrap_delete_RelinkableQuoteHandleVectorVector, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_swigregister", RelinkableQuoteHandleVectorVector_swigregister, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_swiginit", RelinkableQuoteHandleVectorVector_swiginit, METH_VARARGS, NULL},
	 { "Calendar_isWeekend", _wrap_Calendar_isWeekend, METH_VARARGS, NULL},
	 { "Calendar_endOfMonth", _wrap_Calendar_endOfMonth, METH_VARARGS, NULL},
	 { "Calendar_isBusinessDay", _wrap_Calendar_isBusinessDay, METH_VARARGS, NULL},
	 { "Calendar_isHoliday", _wrap_Calendar_isHoliday, METH_VARARGS, NULL},
	 { "Calendar_isEndOfMonth", _wrap_Calendar_isEndOfMonth, METH_VARARGS, NULL},
	 { "Calendar_addHoliday", _wrap_Calendar_addHoliday, METH_VARARGS, NULL},
	 { "Calendar_removeHoliday", _wrap_Calendar_removeHoliday, METH_VARARGS, NULL},
	 { "Calendar_adjust", _wrap_Calendar_adjust, METH_VARARGS, NULL},
	 { "Calendar_advance", _wrap_Calendar_advance, METH_VARARGS, NULL},
	 { "Calendar_businessDaysBetween", _wrap_Calendar_businessDaysBetween, METH_VARARGS, NULL},
	 { "Calendar_holidayList", _wrap_Calendar_holidayList, METH_VARARGS, NULL},
	 { "Calendar_businessDayList", _wrap_Calendar_businessDayList, METH_VARARGS, NULL},
	 { "Calendar_name", _wrap_Calendar_name, METH_O, NULL},
	 { "Calendar___str__", _wrap_Calendar___str__, METH_O, NULL},
	 { "Calendar___eq__", _wrap_Calendar___eq__, METH_VARARGS, NULL},
	 { "Calendar___ne__", _wrap_Calendar___ne__, METH_VARARGS, NULL},
	 { "delete_Calendar", _wrap_delete_Calendar, METH_O, NULL},
	 { "Calendar_swigregister", Calendar_swigregister, METH_O, NULL},
	 { "new_Argentina", _wrap_new_Argentina, METH_VARARGS, NULL},
	 { "delete_Argentina", _wrap_delete_Argentina, METH_O, NULL},
	 { "Argentina_swigregister", Argentina_swigregister, METH_O, NULL},
	 { "Argentina_swiginit", Argentina_swiginit, METH_VARARGS, NULL},
	 { "new_Australia", _wrap_new_Australia, METH_NOARGS, NULL},
	 { "delete_Australia", _wrap_delete_Australia, METH_O, NULL},
	 { "Australia_swigregister", Australia_swigregister, METH_O, NULL},
	 { "Australia_swiginit", Australia_swiginit, METH_VARARGS, NULL},
	 { "new_Brazil", _wrap_new_Brazil, METH_VARARGS, NULL},
	 { "delete_Brazil", _wrap_delete_Brazil, METH_O, NULL},
	 { "Brazil_swigregister", Brazil_swigregister, METH_O, NULL},
	 { "Brazil_swiginit", Brazil_swiginit, METH_VARARGS, NULL},
	 { "new_Canada", _wrap_new_Canada, METH_VARARGS, NULL},
	 { "delete_Canada", _wrap_delete_Canada, METH_O, NULL},
	 { "Canada_swigregister", Canada_swigregister, METH_O, NULL},
	 { "Canada_swiginit", Canada_swiginit, METH_VARARGS, NULL},
	 { "new_China", _wrap_new_China, METH_VARARGS, NULL},
	 { "delete_China", _wrap_delete_China, METH_O, NULL},
	 { "China_swigregister", China_swigregister, METH_O, NULL},
	 { "China_swiginit", China_swiginit, METH_VARARGS, NULL},
	 { "new_CzechRepublic", _wrap_new_CzechRepublic, METH_VARARGS, NULL},
	 { "delete_CzechRepublic", _wrap_delete_CzechRepublic, METH_O, NULL},
	 { "CzechRepublic_swigregister", CzechRepublic_swigregister, METH_O, NULL},
	 { "CzechRepublic_swiginit", CzechRepublic_swiginit, METH_VARARGS, NULL},
	 { "new_Denmark", _wrap_new_Denmark, METH_NOARGS, NULL},
	 { "delete_Denmark", _wrap_delete_Denmark, METH_O, NULL},
	 { "Denmark_swigregister", Denmark_swigregister, METH_O, NULL},
	 { "Denmark_swiginit", Denmark_swiginit, METH_VARARGS, NULL},
	 { "new_Finland", _wrap_new_Finland, METH_NOARGS, NULL},
	 { "delete_Finland", _wrap_delete_Finland, METH_O, NULL},
	 { "Finland_swigregister", Finland_swigregister, METH_O, NULL},
	 { "Finland_swiginit", Finland_swiginit, METH_VARARGS, NULL},
	 { "new_France", _wrap_new_France, METH_VARARGS, NULL},
	 { "delete_France", _wrap_delete_France, METH_O, NULL},
	 { "France_swigregister", France_swigregister, METH_O, NULL},
	 { "France_swiginit", France_swiginit, METH_VARARGS, NULL},
	 { "new_Germany", _wrap_new_Germany, METH_VARARGS, NULL},
	 { "delete_Germany", _wrap_delete_Germany, METH_O, NULL},
	 { "Germany_swigregister", Germany_swigregister, METH_O, NULL},
	 { "Germany_swiginit", Germany_swiginit, METH_VARARGS, NULL},
	 { "new_HongKong", _wrap_new_HongKong, METH_VARARGS, NULL},
	 { "delete_HongKong", _wrap_delete_HongKong, METH_O, NULL},
	 { "HongKong_swigregister", HongKong_swigregister, METH_O, NULL},
	 { "HongKong_swiginit", HongKong_swiginit, METH_VARARGS, NULL},
	 { "new_Hungary", _wrap_new_Hungary, METH_NOARGS, NULL},
	 { "delete_Hungary", _wrap_delete_Hungary, METH_O, NULL},
	 { "Hungary_swigregister", Hungary_swigregister, METH_O, NULL},
	 { "Hungary_swiginit", Hungary_swiginit, METH_VARARGS, NULL},
	 { "new_Iceland", _wrap_new_Iceland, METH_VARARGS, NULL},
	 { "delete_Iceland", _wrap_delete_Iceland, METH_O, NULL},
	 { "Iceland_swigregister", Iceland_swigregister, METH_O, NULL},
	 { "Iceland_swiginit", Iceland_swiginit, METH_VARARGS, NULL},
	 { "new_India", _wrap_new_India, METH_VARARGS, NULL},
	 { "delete_India", _wrap_delete_India, METH_O, NULL},
	 { "India_swigregister", India_swigregister, METH_O, NULL},
	 { "India_swiginit", India_swiginit, METH_VARARGS, NULL},
	 { "new_Indonesia", _wrap_new_Indonesia, METH_VARARGS, NULL},
	 { "delete_Indonesia", _wrap_delete_Indonesia, METH_O, NULL},
	 { "Indonesia_swigregister", Indonesia_swigregister, METH_O, NULL},
	 { "Indonesia_swiginit", Indonesia_swiginit, METH_VARARGS, NULL},
	 { "new_Israel", _wrap_new_Israel, METH_VARARGS, NULL},
	 { "delete_Israel", _wrap_delete_Israel, METH_O, NULL},
	 { "Israel_swigregister", Israel_swigregister, METH_O, NULL},
	 { "Israel_swiginit", Israel_swiginit, METH_VARARGS, NULL},
	 { "new_Italy", _wrap_new_Italy, METH_VARARGS, NULL},
	 { "delete_Italy", _wrap_delete_Italy, METH_O, NULL},
	 { "Italy_swigregister", Italy_swigregister, METH_O, NULL},
	 { "Italy_swiginit", Italy_swiginit, METH_VARARGS, NULL},
	 { "new_Japan", _wrap_new_Japan, METH_NOARGS, NULL},
	 { "delete_Japan", _wrap_delete_Japan, METH_O, NULL},
	 { "Japan_swigregister", Japan_swigregister, METH_O, NULL},
	 { "Japan_swiginit", Japan_swiginit, METH_VARARGS, NULL},
	 { "new_Mexico", _wrap_new_Mexico, METH_VARARGS, NULL},
	 { "delete_Mexico", _wrap_delete_Mexico, METH_O, NULL},
	 { "Mexico_swigregister", Mexico_swigregister, METH_O, NULL},
	 { "Mexico_swiginit", Mexico_swiginit, METH_VARARGS, NULL},
	 { "new_NewZealand", _wrap_new_NewZealand, METH_NOARGS, NULL},
	 { "delete_NewZealand", _wrap_delete_NewZealand, METH_O, NULL},
	 { "NewZealand_swigregister", NewZealand_swigregister, METH_O, NULL},
	 { "NewZealand_swiginit", NewZealand_swiginit, METH_VARARGS, NULL},
	 { "new_Norway", _wrap_new_Norway, METH_NOARGS, NULL},
	 { "delete_Norway", _wrap_delete_Norway, METH_O, NULL},
	 { "Norway_swigregister", Norway_swigregister, METH_O, NULL},
	 { "Norway_swiginit", Norway_swiginit, METH_VARARGS, NULL},
	 { "new_Poland", _wrap_new_Poland, METH_NOARGS, NULL},
	 { "delete_Poland", _wrap_delete_Poland, METH_O, NULL},
	 { "Poland_swigregister", Poland_swigregister, METH_O, NULL},
	 { "Poland_swiginit", Poland_swiginit, METH_VARARGS, NULL},
	 { "new_Russia", _wrap_new_Russia, METH_VARARGS, NULL},
	 { "delete_Russia", _wrap_delete_Russia, METH_O, NULL},
	 { "Russia_swigregister", Russia_swigregister, METH_O, NULL},
	 { "Russia_swiginit", Russia_swiginit, METH_VARARGS, NULL},
	 { "new_Romania", _wrap_new_Romania, METH_NOARGS, NULL},
	 { "delete_Romania", _wrap_delete_Romania, METH_O, NULL},
	 { "Romania_swigregister", Romania_swigregister, METH_O, NULL},
	 { "Romania_swiginit", Romania_swiginit, METH_VARARGS, NULL},
	 { "new_SaudiArabia", _wrap_new_SaudiArabia, METH_VARARGS, NULL},
	 { "delete_SaudiArabia", _wrap_delete_SaudiArabia, METH_O, NULL},
	 { "SaudiArabia_swigregister", SaudiArabia_swigregister, METH_O, NULL},
	 { "SaudiArabia_swiginit", SaudiArabia_swiginit, METH_VARARGS, NULL},
	 { "new_Singapore", _wrap_new_Singapore, METH_VARARGS, NULL},
	 { "delete_Singapore", _wrap_delete_Singapore, METH_O, NULL},
	 { "Singapore_swigregister", Singapore_swigregister, METH_O, NULL},
	 { "Singapore_swiginit", Singapore_swiginit, METH_VARARGS, NULL},
	 { "new_Slovakia", _wrap_new_Slovakia, METH_VARARGS, NULL},
	 { "delete_Slovakia", _wrap_delete_Slovakia, METH_O, NULL},
	 { "Slovakia_swigregister", Slovakia_swigregister, METH_O, NULL},
	 { "Slovakia_swiginit", Slovakia_swiginit, METH_VARARGS, NULL},
	 { "new_SouthAfrica", _wrap_new_SouthAfrica, METH_NOARGS, NULL},
	 { "delete_SouthAfrica", _wrap_delete_SouthAfrica, METH_O, NULL},
	 { "SouthAfrica_swigregister", SouthAfrica_swigregister, METH_O, NULL},
	 { "SouthAfrica_swiginit", SouthAfrica_swiginit, METH_VARARGS, NULL},
	 { "new_SouthKorea", _wrap_new_SouthKorea, METH_VARARGS, NULL},
	 { "delete_SouthKorea", _wrap_delete_SouthKorea, METH_O, NULL},
	 { "SouthKorea_swigregister", SouthKorea_swigregister, METH_O, NULL},
	 { "SouthKorea_swiginit", SouthKorea_swiginit, METH_VARARGS, NULL},
	 { "new_Sweden", _wrap_new_Sweden, METH_NOARGS, NULL},
	 { "delete_Sweden", _wrap_delete_Sweden, METH_O, NULL},
	 { "Sweden_swigregister", Sweden_swigregister, METH_O, NULL},
	 { "Sweden_swiginit", Sweden_swiginit, METH_VARARGS, NULL},
	 { "new_Switzerland", _wrap_new_Switzerland, METH_NOARGS, NULL},
	 { "delete_Switzerland", _wrap_delete_Switzerland, METH_O, NULL},
	 { "Switzerland_swigregister", Switzerland_swigregister, METH_O, NULL},
	 { "Switzerland_swiginit", Switzerland_swiginit, METH_VARARGS, NULL},
	 { "new_Taiwan", _wrap_new_Taiwan, METH_VARARGS, NULL},
	 { "delete_Taiwan", _wrap_delete_Taiwan, METH_O, NULL},
	 { "Taiwan_swigregister", Taiwan_swigregister, METH_O, NULL},
	 { "Taiwan_swiginit", Taiwan_swiginit, METH_VARARGS, NULL},
	 { "new_TARGET", _wrap_new_TARGET, METH_NOARGS, NULL},
	 { "delete_TARGET", _wrap_delete_TARGET, METH_O, NULL},
	 { "TARGET_swigregister", TARGET_swigregister, METH_O, NULL},
	 { "TARGET_swiginit", TARGET_swiginit, METH_VARARGS, NULL},
	 { "new_Thailand", _wrap_new_Thailand, METH_NOARGS, NULL},
	 { "delete_Thailand", _wrap_delete_Thailand, METH_O, NULL},
	 { "Thailand_swigregister", Thailand_swigregister, METH_O, NULL},
	 { "Thailand_swiginit", Thailand_swiginit, METH_VARARGS, NULL},
	 { "new_Turkey", _wrap_new_Turkey, METH_NOARGS, NULL},
	 { "delete_Turkey", _wrap_delete_Turkey, METH_O, NULL},
	 { "Turkey_swigregister", Turkey_swigregister, METH_O, NULL},
	 { "Turkey_swiginit", Turkey_swiginit, METH_VARARGS, NULL},
	 { "new_Ukraine", _wrap_new_Ukraine, METH_VARARGS, NULL},
	 { "delete_Ukraine", _wrap_delete_Ukraine, METH_O, NULL},
	 { "Ukraine_swigregister", Ukraine_swigregister, METH_O, NULL},
	 { "Ukraine_swiginit", Ukraine_swiginit, METH_VARARGS, NULL},
	 { "new_UnitedKingdom", _wrap_new_UnitedKingdom, METH_VARARGS, NULL},
	 { "delete_UnitedKingdom", _wrap_delete_UnitedKingdom, METH_O, NULL},
	 { "UnitedKingdom_swigregister", UnitedKingdom_swigregister, METH_O, NULL},
	 { "UnitedKingdom_swiginit", UnitedKingdom_swiginit, METH_VARARGS, NULL},
	 { "new_UnitedStates", _wrap_new_UnitedStates, METH_VARARGS, NULL},
	 { "delete_UnitedStates", _wrap_delete_UnitedStates, METH_O, NULL},
	 { "UnitedStates_swigregister", UnitedStates_swigregister, METH_O, NULL},
	 { "UnitedStates_swiginit", UnitedStates_swiginit, METH_VARARGS, NULL},
	 { "new_NullCalendar", _wrap_new_NullCalendar, METH_NOARGS, NULL},
	 { "delete_NullCalendar", _wrap_delete_NullCalendar, METH_O, NULL},
	 { "NullCalendar_swigregister", NullCalendar_swigregister, METH_O, NULL},
	 { "NullCalendar_swiginit", NullCalendar_swiginit, METH_VARARGS, NULL},
	 { "new_WeekendsOnly", _wrap_new_WeekendsOnly, METH_NOARGS, NULL},
	 { "delete_WeekendsOnly", _wrap_delete_WeekendsOnly, METH_O, NULL},
	 { "WeekendsOnly_swigregister", WeekendsOnly_swigregister, METH_O, NULL},
	 { "WeekendsOnly_swiginit", WeekendsOnly_swiginit, METH_VARARGS, NULL},
	 { "new_JointCalendar", _wrap_new_JointCalendar, METH_VARARGS, NULL},
	 { "delete_JointCalendar", _wrap_delete_JointCalendar, METH_O, NULL},
	 { "JointCalendar_swigregister", JointCalendar_swigregister, METH_O, NULL},
	 { "JointCalendar_swiginit", JointCalendar_swiginit, METH_VARARGS, NULL},
	 { "new_BespokeCalendar", _wrap_new_BespokeCalendar, METH_O, NULL},
	 { "BespokeCalendar_addWeekend", _wrap_BespokeCalendar_addWeekend, METH_VARARGS, NULL},
	 { "delete_BespokeCalendar", _wrap_delete_BespokeCalendar, METH_O, NULL},
	 { "BespokeCalendar_swigregister", BespokeCalendar_swigregister, METH_O, NULL},
	 { "BespokeCalendar_swiginit", BespokeCalendar_swiginit, METH_VARARGS, NULL},
	 { "nullInt", _wrap_nullInt, METH_NOARGS, NULL},
	 { "nullDouble", _wrap_nullDouble, METH_NOARGS, NULL},
	 { "DayCounter_dayCount", _wrap_DayCounter_dayCount, METH_VARARGS, NULL},
	 { "DayCounter_yearFraction", _wrap_DayCounter_yearFraction, METH_VARARGS, NULL},
	 { "DayCounter_name", _wrap_DayCounter_name, METH_O, NULL},
	 { "DayCounter___str__", _wrap_DayCounter___str__, METH_O, NULL},
	 { "DayCounter___eq__", _wrap_DayCounter___eq__, METH_VARARGS, NULL},
	 { "DayCounter___ne__", _wrap_DayCounter___ne__, METH_VARARGS, NULL},
	 { "delete_DayCounter", _wrap_delete_DayCounter, METH_O, NULL},
	 { "DayCounter_swigregister", DayCounter_swigregister, METH_O, NULL},
	 { "new_Actual360", _wrap_new_Actual360, METH_VARARGS, NULL},
	 { "delete_Actual360", _wrap_delete_Actual360, METH_O, NULL},
	 { "Actual360_swigregister", Actual360_swigregister, METH_O, NULL},
	 { "Actual360_swiginit", Actual360_swiginit, METH_VARARGS, NULL},
	 { "new_Actual364", _wrap_new_Actual364, METH_NOARGS, NULL},
	 { "delete_Actual364", _wrap_delete_Actual364, METH_O, NULL},
	 { "Actual364_swigregister", Actual364_swigregister, METH_O, NULL},
	 { "Actual364_swiginit", Actual364_swiginit, METH_VARARGS, NULL},
	 { "new_Actual365Fixed", _wrap_new_Actual365Fixed, METH_VARARGS, NULL},
	 { "delete_Actual365Fixed", _wrap_delete_Actual365Fixed, METH_O, NULL},
	 { "Actual365Fixed_swigregister", Actual365Fixed_swigregister, METH_O, NULL},
	 { "Actual365Fixed_swiginit", Actual365Fixed_swiginit, METH_VARARGS, NULL},
	 { "new_Thirty360", _wrap_new_Thirty360, METH_VARARGS, NULL},
	 { "delete_Thirty360", _wrap_delete_Thirty360, METH_O, NULL},
	 { "Thirty360_swigregister", Thirty360_swigregister, METH_O, NULL},
	 { "Thirty360_swiginit", Thirty360_swiginit, METH_VARARGS, NULL},
	 { "new_Thirty365", _wrap_new_Thirty365, METH_NOARGS, NULL},
	 { "delete_Thirty365", _wrap_delete_Thirty365, METH_O, NULL},
	 { "Thirty365_swigregister", Thirty365_swigregister, METH_O, NULL},
	 { "Thirty365_swiginit", Thirty365_swiginit, METH_VARARGS, NULL},
	 { "new_ActualActual", _wrap_new_ActualActual, METH_VARARGS, NULL},
	 { "delete_ActualActual", _wrap_delete_ActualActual, METH_O, NULL},
	 { "ActualActual_swigregister", ActualActual_swigregister, METH_O, NULL},
	 { "ActualActual_swiginit", ActualActual_swiginit, METH_VARARGS, NULL},
	 { "new_OneDayCounter", _wrap_new_OneDayCounter, METH_NOARGS, NULL},
	 { "delete_OneDayCounter", _wrap_delete_OneDayCounter, METH_O, NULL},
	 { "OneDayCounter_swigregister", OneDayCounter_swigregister, METH_O, NULL},
	 { "OneDayCounter_swiginit", OneDayCounter_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleDayCounter", _wrap_new_SimpleDayCounter, METH_NOARGS, NULL},
	 { "delete_SimpleDayCounter", _wrap_delete_SimpleDayCounter, METH_O, NULL},
	 { "SimpleDayCounter_swigregister", SimpleDayCounter_swigregister, METH_O, NULL},
	 { "SimpleDayCounter_swiginit", SimpleDayCounter_swiginit, METH_VARARGS, NULL},
	 { "new_Business252", _wrap_new_Business252, METH_VARARGS, NULL},
	 { "delete_Business252", _wrap_delete_Business252, METH_O, NULL},
	 { "Business252_swigregister", Business252_swigregister, METH_O, NULL},
	 { "Business252_swiginit", Business252_swiginit, METH_VARARGS, NULL},
	 { "new_InterestRate", _wrap_new_InterestRate, METH_VARARGS, NULL},
	 { "InterestRate_rate", _wrap_InterestRate_rate, METH_O, NULL},
	 { "InterestRate_dayCounter", _wrap_InterestRate_dayCounter, METH_O, NULL},
	 { "InterestRate_compounding", _wrap_InterestRate_compounding, METH_O, NULL},
	 { "InterestRate_frequency", _wrap_InterestRate_frequency, METH_O, NULL},
	 { "InterestRate_discountFactor", _wrap_InterestRate_discountFactor, METH_VARARGS, NULL},
	 { "InterestRate_compoundFactor", _wrap_InterestRate_compoundFactor, METH_VARARGS, NULL},
	 { "InterestRate_impliedRate", _wrap_InterestRate_impliedRate, METH_VARARGS, NULL},
	 { "InterestRate_equivalentRate", _wrap_InterestRate_equivalentRate, METH_VARARGS, NULL},
	 { "InterestRate___str__", _wrap_InterestRate___str__, METH_O, NULL},
	 { "delete_InterestRate", _wrap_delete_InterestRate, METH_O, NULL},
	 { "InterestRate_swigregister", InterestRate_swigregister, METH_O, NULL},
	 { "InterestRate_swiginit", InterestRate_swiginit, METH_VARARGS, NULL},
	 { "InterestRateVector_iterator", _wrap_InterestRateVector_iterator, METH_O, NULL},
	 { "InterestRateVector___nonzero__", _wrap_InterestRateVector___nonzero__, METH_O, NULL},
	 { "InterestRateVector___bool__", _wrap_InterestRateVector___bool__, METH_O, NULL},
	 { "InterestRateVector___len__", _wrap_InterestRateVector___len__, METH_O, NULL},
	 { "InterestRateVector___getslice__", _wrap_InterestRateVector___getslice__, METH_VARARGS, NULL},
	 { "InterestRateVector___setslice__", _wrap_InterestRateVector___setslice__, METH_VARARGS, NULL},
	 { "InterestRateVector___delslice__", _wrap_InterestRateVector___delslice__, METH_VARARGS, NULL},
	 { "InterestRateVector___delitem__", _wrap_InterestRateVector___delitem__, METH_VARARGS, NULL},
	 { "InterestRateVector___getitem__", _wrap_InterestRateVector___getitem__, METH_VARARGS, NULL},
	 { "InterestRateVector___setitem__", _wrap_InterestRateVector___setitem__, METH_VARARGS, NULL},
	 { "InterestRateVector_pop", _wrap_InterestRateVector_pop, METH_O, NULL},
	 { "InterestRateVector_append", _wrap_InterestRateVector_append, METH_VARARGS, NULL},
	 { "InterestRateVector_empty", _wrap_InterestRateVector_empty, METH_O, NULL},
	 { "InterestRateVector_size", _wrap_InterestRateVector_size, METH_O, NULL},
	 { "InterestRateVector_swap", _wrap_InterestRateVector_swap, METH_VARARGS, NULL},
	 { "InterestRateVector_begin", _wrap_InterestRateVector_begin, METH_O, NULL},
	 { "InterestRateVector_end", _wrap_InterestRateVector_end, METH_O, NULL},
	 { "InterestRateVector_rbegin", _wrap_InterestRateVector_rbegin, METH_O, NULL},
	 { "InterestRateVector_rend", _wrap_InterestRateVector_rend, METH_O, NULL},
	 { "InterestRateVector_clear", _wrap_InterestRateVector_clear, METH_O, NULL},
	 { "InterestRateVector_get_allocator", _wrap_InterestRateVector_get_allocator, METH_O, NULL},
	 { "InterestRateVector_pop_back", _wrap_InterestRateVector_pop_back, METH_O, NULL},
	 { "InterestRateVector_erase", _wrap_InterestRateVector_erase, METH_VARARGS, NULL},
	 { "new_InterestRateVector", _wrap_new_InterestRateVector, METH_VARARGS, NULL},
	 { "InterestRateVector_push_back", _wrap_InterestRateVector_push_back, METH_VARARGS, NULL},
	 { "InterestRateVector_front", _wrap_InterestRateVector_front, METH_O, NULL},
	 { "InterestRateVector_back", _wrap_InterestRateVector_back, METH_O, NULL},
	 { "InterestRateVector_assign", _wrap_InterestRateVector_assign, METH_VARARGS, NULL},
	 { "InterestRateVector_resize", _wrap_InterestRateVector_resize, METH_VARARGS, NULL},
	 { "InterestRateVector_insert", _wrap_InterestRateVector_insert, METH_VARARGS, NULL},
	 { "InterestRateVector_reserve", _wrap_InterestRateVector_reserve, METH_VARARGS, NULL},
	 { "InterestRateVector_capacity", _wrap_InterestRateVector_capacity, METH_O, NULL},
	 { "delete_InterestRateVector", _wrap_delete_InterestRateVector, METH_O, NULL},
	 { "InterestRateVector_swigregister", InterestRateVector_swigregister, METH_O, NULL},
	 { "InterestRateVector_swiginit", InterestRateVector_swiginit, METH_VARARGS, NULL},
	 { "new_Rounding", _wrap_new_Rounding, METH_NOARGS, NULL},
	 { "Rounding___call__", _wrap_Rounding___call__, METH_VARARGS, NULL},
	 { "delete_Rounding", _wrap_delete_Rounding, METH_O, NULL},
	 { "Rounding_swigregister", Rounding_swigregister, METH_O, NULL},
	 { "Rounding_swiginit", Rounding_swiginit, METH_VARARGS, NULL},
	 { "new_UpRounding", _wrap_new_UpRounding, METH_VARARGS, NULL},
	 { "delete_UpRounding", _wrap_delete_UpRounding, METH_O, NULL},
	 { "UpRounding_swigregister", UpRounding_swigregister, METH_O, NULL},
	 { "UpRounding_swiginit", UpRounding_swiginit, METH_VARARGS, NULL},
	 { "new_DownRounding", _wrap_new_DownRounding, METH_VARARGS, NULL},
	 { "delete_DownRounding", _wrap_delete_DownRounding, METH_O, NULL},
	 { "DownRounding_swigregister", DownRounding_swigregister, METH_O, NULL},
	 { "DownRounding_swiginit", DownRounding_swiginit, METH_VARARGS, NULL},
	 { "new_ClosestRounding", _wrap_new_ClosestRounding, METH_VARARGS, NULL},
	 { "delete_ClosestRounding", _wrap_delete_ClosestRounding, METH_O, NULL},
	 { "ClosestRounding_swigregister", ClosestRounding_swigregister, METH_O, NULL},
	 { "ClosestRounding_swiginit", ClosestRounding_swiginit, METH_VARARGS, NULL},
	 { "new_CeilingTruncation", _wrap_new_CeilingTruncation, METH_VARARGS, NULL},
	 { "delete_CeilingTruncation", _wrap_delete_CeilingTruncation, METH_O, NULL},
	 { "CeilingTruncation_swigregister", CeilingTruncation_swigregister, METH_O, NULL},
	 { "CeilingTruncation_swiginit", CeilingTruncation_swiginit, METH_VARARGS, NULL},
	 { "new_FloorTruncation", _wrap_new_FloorTruncation, METH_VARARGS, NULL},
	 { "delete_FloorTruncation", _wrap_delete_FloorTruncation, METH_O, NULL},
	 { "FloorTruncation_swigregister", FloorTruncation_swigregister, METH_O, NULL},
	 { "FloorTruncation_swiginit", FloorTruncation_swiginit, METH_VARARGS, NULL},
	 { "Currency_name", _wrap_Currency_name, METH_O, NULL},
	 { "Currency_code", _wrap_Currency_code, METH_O, NULL},
	 { "Currency_numericCode", _wrap_Currency_numericCode, METH_O, NULL},
	 { "Currency_symbol", _wrap_Currency_symbol, METH_O, NULL},
	 { "Currency_fractionSymbol", _wrap_Currency_fractionSymbol, METH_O, NULL},
	 { "Currency_fractionsPerUnit", _wrap_Currency_fractionsPerUnit, METH_O, NULL},
	 { "Currency_rounding", _wrap_Currency_rounding, METH_O, NULL},
	 { "Currency_format", _wrap_Currency_format, METH_O, NULL},
	 { "Currency_empty", _wrap_Currency_empty, METH_O, NULL},
	 { "Currency_triangulationCurrency", _wrap_Currency_triangulationCurrency, METH_O, NULL},
	 { "Currency___str__", _wrap_Currency___str__, METH_O, NULL},
	 { "Currency___eq__", _wrap_Currency___eq__, METH_VARARGS, NULL},
	 { "Currency___ne__", _wrap_Currency___ne__, METH_VARARGS, NULL},
	 { "Currency___mul__", _wrap_Currency___mul__, METH_VARARGS, NULL},
	 { "Currency___rmul__", _wrap_Currency___rmul__, METH_VARARGS, NULL},
	 { "Currency___nonzero__", _wrap_Currency___nonzero__, METH_O, NULL},
	 { "Currency___bool__", _wrap_Currency___bool__, METH_O, NULL},
	 { "new_Currency", _wrap_new_Currency, METH_NOARGS, NULL},
	 { "delete_Currency", _wrap_delete_Currency, METH_O, NULL},
	 { "Currency_swigregister", Currency_swigregister, METH_O, NULL},
	 { "Currency_swiginit", Currency_swiginit, METH_VARARGS, NULL},
	 { "new_ARSCurrency", _wrap_new_ARSCurrency, METH_NOARGS, NULL},
	 { "delete_ARSCurrency", _wrap_delete_ARSCurrency, METH_O, NULL},
	 { "ARSCurrency_swigregister", ARSCurrency_swigregister, METH_O, NULL},
	 { "ARSCurrency_swiginit", ARSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ATSCurrency", _wrap_new_ATSCurrency, METH_NOARGS, NULL},
	 { "delete_ATSCurrency", _wrap_delete_ATSCurrency, METH_O, NULL},
	 { "ATSCurrency_swigregister", ATSCurrency_swigregister, METH_O, NULL},
	 { "ATSCurrency_swiginit", ATSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_AUDCurrency", _wrap_new_AUDCurrency, METH_NOARGS, NULL},
	 { "delete_AUDCurrency", _wrap_delete_AUDCurrency, METH_O, NULL},
	 { "AUDCurrency_swigregister", AUDCurrency_swigregister, METH_O, NULL},
	 { "AUDCurrency_swiginit", AUDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BDTCurrency", _wrap_new_BDTCurrency, METH_NOARGS, NULL},
	 { "delete_BDTCurrency", _wrap_delete_BDTCurrency, METH_O, NULL},
	 { "BDTCurrency_swigregister", BDTCurrency_swigregister, METH_O, NULL},
	 { "BDTCurrency_swiginit", BDTCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BEFCurrency", _wrap_new_BEFCurrency, METH_NOARGS, NULL},
	 { "delete_BEFCurrency", _wrap_delete_BEFCurrency, METH_O, NULL},
	 { "BEFCurrency_swigregister", BEFCurrency_swigregister, METH_O, NULL},
	 { "BEFCurrency_swiginit", BEFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BGLCurrency", _wrap_new_BGLCurrency, METH_NOARGS, NULL},
	 { "delete_BGLCurrency", _wrap_delete_BGLCurrency, METH_O, NULL},
	 { "BGLCurrency_swigregister", BGLCurrency_swigregister, METH_O, NULL},
	 { "BGLCurrency_swiginit", BGLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BRLCurrency", _wrap_new_BRLCurrency, METH_NOARGS, NULL},
	 { "delete_BRLCurrency", _wrap_delete_BRLCurrency, METH_O, NULL},
	 { "BRLCurrency_swigregister", BRLCurrency_swigregister, METH_O, NULL},
	 { "BRLCurrency_swiginit", BRLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BYRCurrency", _wrap_new_BYRCurrency, METH_NOARGS, NULL},
	 { "delete_BYRCurrency", _wrap_delete_BYRCurrency, METH_O, NULL},
	 { "BYRCurrency_swigregister", BYRCurrency_swigregister, METH_O, NULL},
	 { "BYRCurrency_swiginit", BYRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CADCurrency", _wrap_new_CADCurrency, METH_NOARGS, NULL},
	 { "delete_CADCurrency", _wrap_delete_CADCurrency, METH_O, NULL},
	 { "CADCurrency_swigregister", CADCurrency_swigregister, METH_O, NULL},
	 { "CADCurrency_swiginit", CADCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CHFCurrency", _wrap_new_CHFCurrency, METH_NOARGS, NULL},
	 { "delete_CHFCurrency", _wrap_delete_CHFCurrency, METH_O, NULL},
	 { "CHFCurrency_swigregister", CHFCurrency_swigregister, METH_O, NULL},
	 { "CHFCurrency_swiginit", CHFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CLPCurrency", _wrap_new_CLPCurrency, METH_NOARGS, NULL},
	 { "delete_CLPCurrency", _wrap_delete_CLPCurrency, METH_O, NULL},
	 { "CLPCurrency_swigregister", CLPCurrency_swigregister, METH_O, NULL},
	 { "CLPCurrency_swiginit", CLPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CNYCurrency", _wrap_new_CNYCurrency, METH_NOARGS, NULL},
	 { "delete_CNYCurrency", _wrap_delete_CNYCurrency, METH_O, NULL},
	 { "CNYCurrency_swigregister", CNYCurrency_swigregister, METH_O, NULL},
	 { "CNYCurrency_swiginit", CNYCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_COPCurrency", _wrap_new_COPCurrency, METH_NOARGS, NULL},
	 { "delete_COPCurrency", _wrap_delete_COPCurrency, METH_O, NULL},
	 { "COPCurrency_swigregister", COPCurrency_swigregister, METH_O, NULL},
	 { "COPCurrency_swiginit", COPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CYPCurrency", _wrap_new_CYPCurrency, METH_NOARGS, NULL},
	 { "delete_CYPCurrency", _wrap_delete_CYPCurrency, METH_O, NULL},
	 { "CYPCurrency_swigregister", CYPCurrency_swigregister, METH_O, NULL},
	 { "CYPCurrency_swiginit", CYPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CZKCurrency", _wrap_new_CZKCurrency, METH_NOARGS, NULL},
	 { "delete_CZKCurrency", _wrap_delete_CZKCurrency, METH_O, NULL},
	 { "CZKCurrency_swigregister", CZKCurrency_swigregister, METH_O, NULL},
	 { "CZKCurrency_swiginit", CZKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_DEMCurrency", _wrap_new_DEMCurrency, METH_NOARGS, NULL},
	 { "delete_DEMCurrency", _wrap_delete_DEMCurrency, METH_O, NULL},
	 { "DEMCurrency_swigregister", DEMCurrency_swigregister, METH_O, NULL},
	 { "DEMCurrency_swiginit", DEMCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_DKKCurrency", _wrap_new_DKKCurrency, METH_NOARGS, NULL},
	 { "delete_DKKCurrency", _wrap_delete_DKKCurrency, METH_O, NULL},
	 { "DKKCurrency_swigregister", DKKCurrency_swigregister, METH_O, NULL},
	 { "DKKCurrency_swiginit", DKKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_EEKCurrency", _wrap_new_EEKCurrency, METH_NOARGS, NULL},
	 { "delete_EEKCurrency", _wrap_delete_EEKCurrency, METH_O, NULL},
	 { "EEKCurrency_swigregister", EEKCurrency_swigregister, METH_O, NULL},
	 { "EEKCurrency_swiginit", EEKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ESPCurrency", _wrap_new_ESPCurrency, METH_NOARGS, NULL},
	 { "delete_ESPCurrency", _wrap_delete_ESPCurrency, METH_O, NULL},
	 { "ESPCurrency_swigregister", ESPCurrency_swigregister, METH_O, NULL},
	 { "ESPCurrency_swiginit", ESPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_EURCurrency", _wrap_new_EURCurrency, METH_NOARGS, NULL},
	 { "delete_EURCurrency", _wrap_delete_EURCurrency, METH_O, NULL},
	 { "EURCurrency_swigregister", EURCurrency_swigregister, METH_O, NULL},
	 { "EURCurrency_swiginit", EURCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_FIMCurrency", _wrap_new_FIMCurrency, METH_NOARGS, NULL},
	 { "delete_FIMCurrency", _wrap_delete_FIMCurrency, METH_O, NULL},
	 { "FIMCurrency_swigregister", FIMCurrency_swigregister, METH_O, NULL},
	 { "FIMCurrency_swiginit", FIMCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_FRFCurrency", _wrap_new_FRFCurrency, METH_NOARGS, NULL},
	 { "delete_FRFCurrency", _wrap_delete_FRFCurrency, METH_O, NULL},
	 { "FRFCurrency_swigregister", FRFCurrency_swigregister, METH_O, NULL},
	 { "FRFCurrency_swiginit", FRFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_GBPCurrency", _wrap_new_GBPCurrency, METH_NOARGS, NULL},
	 { "delete_GBPCurrency", _wrap_delete_GBPCurrency, METH_O, NULL},
	 { "GBPCurrency_swigregister", GBPCurrency_swigregister, METH_O, NULL},
	 { "GBPCurrency_swiginit", GBPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_GRDCurrency", _wrap_new_GRDCurrency, METH_NOARGS, NULL},
	 { "delete_GRDCurrency", _wrap_delete_GRDCurrency, METH_O, NULL},
	 { "GRDCurrency_swigregister", GRDCurrency_swigregister, METH_O, NULL},
	 { "GRDCurrency_swiginit", GRDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_HKDCurrency", _wrap_new_HKDCurrency, METH_NOARGS, NULL},
	 { "delete_HKDCurrency", _wrap_delete_HKDCurrency, METH_O, NULL},
	 { "HKDCurrency_swigregister", HKDCurrency_swigregister, METH_O, NULL},
	 { "HKDCurrency_swiginit", HKDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_HUFCurrency", _wrap_new_HUFCurrency, METH_NOARGS, NULL},
	 { "delete_HUFCurrency", _wrap_delete_HUFCurrency, METH_O, NULL},
	 { "HUFCurrency_swigregister", HUFCurrency_swigregister, METH_O, NULL},
	 { "HUFCurrency_swiginit", HUFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IEPCurrency", _wrap_new_IEPCurrency, METH_NOARGS, NULL},
	 { "delete_IEPCurrency", _wrap_delete_IEPCurrency, METH_O, NULL},
	 { "IEPCurrency_swigregister", IEPCurrency_swigregister, METH_O, NULL},
	 { "IEPCurrency_swiginit", IEPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IDRCurrency", _wrap_new_IDRCurrency, METH_NOARGS, NULL},
	 { "delete_IDRCurrency", _wrap_delete_IDRCurrency, METH_O, NULL},
	 { "IDRCurrency_swigregister", IDRCurrency_swigregister, METH_O, NULL},
	 { "IDRCurrency_swiginit", IDRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ILSCurrency", _wrap_new_ILSCurrency, METH_NOARGS, NULL},
	 { "delete_ILSCurrency", _wrap_delete_ILSCurrency, METH_O, NULL},
	 { "ILSCurrency_swigregister", ILSCurrency_swigregister, METH_O, NULL},
	 { "ILSCurrency_swiginit", ILSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_INRCurrency", _wrap_new_INRCurrency, METH_NOARGS, NULL},
	 { "delete_INRCurrency", _wrap_delete_INRCurrency, METH_O, NULL},
	 { "INRCurrency_swigregister", INRCurrency_swigregister, METH_O, NULL},
	 { "INRCurrency_swiginit", INRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IQDCurrency", _wrap_new_IQDCurrency, METH_NOARGS, NULL},
	 { "delete_IQDCurrency", _wrap_delete_IQDCurrency, METH_O, NULL},
	 { "IQDCurrency_swigregister", IQDCurrency_swigregister, METH_O, NULL},
	 { "IQDCurrency_swiginit", IQDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IRRCurrency", _wrap_new_IRRCurrency, METH_NOARGS, NULL},
	 { "delete_IRRCurrency", _wrap_delete_IRRCurrency, METH_O, NULL},
	 { "IRRCurrency_swigregister", IRRCurrency_swigregister, METH_O, NULL},
	 { "IRRCurrency_swiginit", IRRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ISKCurrency", _wrap_new_ISKCurrency, METH_NOARGS, NULL},
	 { "delete_ISKCurrency", _wrap_delete_ISKCurrency, METH_O, NULL},
	 { "ISKCurrency_swigregister", ISKCurrency_swigregister, METH_O, NULL},
	 { "ISKCurrency_swiginit", ISKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ITLCurrency", _wrap_new_ITLCurrency, METH_NOARGS, NULL},
	 { "delete_ITLCurrency", _wrap_delete_ITLCurrency, METH_O, NULL},
	 { "ITLCurrency_swigregister", ITLCurrency_swigregister, METH_O, NULL},
	 { "ITLCurrency_swiginit", ITLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_JPYCurrency", _wrap_new_JPYCurrency, METH_NOARGS, NULL},
	 { "delete_JPYCurrency", _wrap_delete_JPYCurrency, METH_O, NULL},
	 { "JPYCurrency_swigregister", JPYCurrency_swigregister, METH_O, NULL},
	 { "JPYCurrency_swiginit", JPYCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_KRWCurrency", _wrap_new_KRWCurrency, METH_NOARGS, NULL},
	 { "delete_KRWCurrency", _wrap_delete_KRWCurrency, METH_O, NULL},
	 { "KRWCurrency_swigregister", KRWCurrency_swigregister, METH_O, NULL},
	 { "KRWCurrency_swiginit", KRWCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_KWDCurrency", _wrap_new_KWDCurrency, METH_NOARGS, NULL},
	 { "delete_KWDCurrency", _wrap_delete_KWDCurrency, METH_O, NULL},
	 { "KWDCurrency_swigregister", KWDCurrency_swigregister, METH_O, NULL},
	 { "KWDCurrency_swiginit", KWDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LTLCurrency", _wrap_new_LTLCurrency, METH_NOARGS, NULL},
	 { "delete_LTLCurrency", _wrap_delete_LTLCurrency, METH_O, NULL},
	 { "LTLCurrency_swigregister", LTLCurrency_swigregister, METH_O, NULL},
	 { "LTLCurrency_swiginit", LTLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LUFCurrency", _wrap_new_LUFCurrency, METH_NOARGS, NULL},
	 { "delete_LUFCurrency", _wrap_delete_LUFCurrency, METH_O, NULL},
	 { "LUFCurrency_swigregister", LUFCurrency_swigregister, METH_O, NULL},
	 { "LUFCurrency_swiginit", LUFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LVLCurrency", _wrap_new_LVLCurrency, METH_NOARGS, NULL},
	 { "delete_LVLCurrency", _wrap_delete_LVLCurrency, METH_O, NULL},
	 { "LVLCurrency_swigregister", LVLCurrency_swigregister, METH_O, NULL},
	 { "LVLCurrency_swiginit", LVLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MTLCurrency", _wrap_new_MTLCurrency, METH_NOARGS, NULL},
	 { "delete_MTLCurrency", _wrap_delete_MTLCurrency, METH_O, NULL},
	 { "MTLCurrency_swigregister", MTLCurrency_swigregister, METH_O, NULL},
	 { "MTLCurrency_swiginit", MTLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MXNCurrency", _wrap_new_MXNCurrency, METH_NOARGS, NULL},
	 { "delete_MXNCurrency", _wrap_delete_MXNCurrency, METH_O, NULL},
	 { "MXNCurrency_swigregister", MXNCurrency_swigregister, METH_O, NULL},
	 { "MXNCurrency_swiginit", MXNCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MYRCurrency", _wrap_new_MYRCurrency, METH_NOARGS, NULL},
	 { "delete_MYRCurrency", _wrap_delete_MYRCurrency, METH_O, NULL},
	 { "MYRCurrency_swigregister", MYRCurrency_swigregister, METH_O, NULL},
	 { "MYRCurrency_swiginit", MYRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NLGCurrency", _wrap_new_NLGCurrency, METH_NOARGS, NULL},
	 { "delete_NLGCurrency", _wrap_delete_NLGCurrency, METH_O, NULL},
	 { "NLGCurrency_swigregister", NLGCurrency_swigregister, METH_O, NULL},
	 { "NLGCurrency_swiginit", NLGCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NOKCurrency", _wrap_new_NOKCurrency, METH_NOARGS, NULL},
	 { "delete_NOKCurrency", _wrap_delete_NOKCurrency, METH_O, NULL},
	 { "NOKCurrency_swigregister", NOKCurrency_swigregister, METH_O, NULL},
	 { "NOKCurrency_swiginit", NOKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NPRCurrency", _wrap_new_NPRCurrency, METH_NOARGS, NULL},
	 { "delete_NPRCurrency", _wrap_delete_NPRCurrency, METH_O, NULL},
	 { "NPRCurrency_swigregister", NPRCurrency_swigregister, METH_O, NULL},
	 { "NPRCurrency_swiginit", NPRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NZDCurrency", _wrap_new_NZDCurrency, METH_NOARGS, NULL},
	 { "delete_NZDCurrency", _wrap_delete_NZDCurrency, METH_O, NULL},
	 { "NZDCurrency_swigregister", NZDCurrency_swigregister, METH_O, NULL},
	 { "NZDCurrency_swiginit", NZDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PEHCurrency", _wrap_new_PEHCurrency, METH_NOARGS, NULL},
	 { "delete_PEHCurrency", _wrap_delete_PEHCurrency, METH_O, NULL},
	 { "PEHCurrency_swigregister", PEHCurrency_swigregister, METH_O, NULL},
	 { "PEHCurrency_swiginit", PEHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PEICurrency", _wrap_new_PEICurrency, METH_NOARGS, NULL},
	 { "delete_PEICurrency", _wrap_delete_PEICurrency, METH_O, NULL},
	 { "PEICurrency_swigregister", PEICurrency_swigregister, METH_O, NULL},
	 { "PEICurrency_swiginit", PEICurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PENCurrency", _wrap_new_PENCurrency, METH_NOARGS, NULL},
	 { "delete_PENCurrency", _wrap_delete_PENCurrency, METH_O, NULL},
	 { "PENCurrency_swigregister", PENCurrency_swigregister, METH_O, NULL},
	 { "PENCurrency_swiginit", PENCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PKRCurrency", _wrap_new_PKRCurrency, METH_NOARGS, NULL},
	 { "delete_PKRCurrency", _wrap_delete_PKRCurrency, METH_O, NULL},
	 { "PKRCurrency_swigregister", PKRCurrency_swigregister, METH_O, NULL},
	 { "PKRCurrency_swiginit", PKRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PLNCurrency", _wrap_new_PLNCurrency, METH_NOARGS, NULL},
	 { "delete_PLNCurrency", _wrap_delete_PLNCurrency, METH_O, NULL},
	 { "PLNCurrency_swigregister", PLNCurrency_swigregister, METH_O, NULL},
	 { "PLNCurrency_swiginit", PLNCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PTECurrency", _wrap_new_PTECurrency, METH_NOARGS, NULL},
	 { "delete_PTECurrency", _wrap_delete_PTECurrency, METH_O, NULL},
	 { "PTECurrency_swigregister", PTECurrency_swigregister, METH_O, NULL},
	 { "PTECurrency_swiginit", PTECurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ROLCurrency", _wrap_new_ROLCurrency, METH_NOARGS, NULL},
	 { "delete_ROLCurrency", _wrap_delete_ROLCurrency, METH_O, NULL},
	 { "ROLCurrency_swigregister", ROLCurrency_swigregister, METH_O, NULL},
	 { "ROLCurrency_swiginit", ROLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_RONCurrency", _wrap_new_RONCurrency, METH_NOARGS, NULL},
	 { "delete_RONCurrency", _wrap_delete_RONCurrency, METH_O, NULL},
	 { "RONCurrency_swigregister", RONCurrency_swigregister, METH_O, NULL},
	 { "RONCurrency_swiginit", RONCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_RUBCurrency", _wrap_new_RUBCurrency, METH_NOARGS, NULL},
	 { "delete_RUBCurrency", _wrap_delete_RUBCurrency, METH_O, NULL},
	 { "RUBCurrency_swigregister", RUBCurrency_swigregister, METH_O, NULL},
	 { "RUBCurrency_swiginit", RUBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SARCurrency", _wrap_new_SARCurrency, METH_NOARGS, NULL},
	 { "delete_SARCurrency", _wrap_delete_SARCurrency, METH_O, NULL},
	 { "SARCurrency_swigregister", SARCurrency_swigregister, METH_O, NULL},
	 { "SARCurrency_swiginit", SARCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SEKCurrency", _wrap_new_SEKCurrency, METH_NOARGS, NULL},
	 { "delete_SEKCurrency", _wrap_delete_SEKCurrency, METH_O, NULL},
	 { "SEKCurrency_swigregister", SEKCurrency_swigregister, METH_O, NULL},
	 { "SEKCurrency_swiginit", SEKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SGDCurrency", _wrap_new_SGDCurrency, METH_NOARGS, NULL},
	 { "delete_SGDCurrency", _wrap_delete_SGDCurrency, METH_O, NULL},
	 { "SGDCurrency_swigregister", SGDCurrency_swigregister, METH_O, NULL},
	 { "SGDCurrency_swiginit", SGDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SITCurrency", _wrap_new_SITCurrency, METH_NOARGS, NULL},
	 { "delete_SITCurrency", _wrap_delete_SITCurrency, METH_O, NULL},
	 { "SITCurrency_swigregister", SITCurrency_swigregister, METH_O, NULL},
	 { "SITCurrency_swiginit", SITCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SKKCurrency", _wrap_new_SKKCurrency, METH_NOARGS, NULL},
	 { "delete_SKKCurrency", _wrap_delete_SKKCurrency, METH_O, NULL},
	 { "SKKCurrency_swigregister", SKKCurrency_swigregister, METH_O, NULL},
	 { "SKKCurrency_swiginit", SKKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_THBCurrency", _wrap_new_THBCurrency, METH_NOARGS, NULL},
	 { "delete_THBCurrency", _wrap_delete_THBCurrency, METH_O, NULL},
	 { "THBCurrency_swigregister", THBCurrency_swigregister, METH_O, NULL},
	 { "THBCurrency_swiginit", THBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TRLCurrency", _wrap_new_TRLCurrency, METH_NOARGS, NULL},
	 { "delete_TRLCurrency", _wrap_delete_TRLCurrency, METH_O, NULL},
	 { "TRLCurrency_swigregister", TRLCurrency_swigregister, METH_O, NULL},
	 { "TRLCurrency_swiginit", TRLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TRYCurrency", _wrap_new_TRYCurrency, METH_NOARGS, NULL},
	 { "delete_TRYCurrency", _wrap_delete_TRYCurrency, METH_O, NULL},
	 { "TRYCurrency_swigregister", TRYCurrency_swigregister, METH_O, NULL},
	 { "TRYCurrency_swiginit", TRYCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TTDCurrency", _wrap_new_TTDCurrency, METH_NOARGS, NULL},
	 { "delete_TTDCurrency", _wrap_delete_TTDCurrency, METH_O, NULL},
	 { "TTDCurrency_swigregister", TTDCurrency_swigregister, METH_O, NULL},
	 { "TTDCurrency_swiginit", TTDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TWDCurrency", _wrap_new_TWDCurrency, METH_NOARGS, NULL},
	 { "delete_TWDCurrency", _wrap_delete_TWDCurrency, METH_O, NULL},
	 { "TWDCurrency_swigregister", TWDCurrency_swigregister, METH_O, NULL},
	 { "TWDCurrency_swiginit", TWDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_USDCurrency", _wrap_new_USDCurrency, METH_NOARGS, NULL},
	 { "delete_USDCurrency", _wrap_delete_USDCurrency, METH_O, NULL},
	 { "USDCurrency_swigregister", USDCurrency_swigregister, METH_O, NULL},
	 { "USDCurrency_swiginit", USDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_VEBCurrency", _wrap_new_VEBCurrency, METH_NOARGS, NULL},
	 { "delete_VEBCurrency", _wrap_delete_VEBCurrency, METH_O, NULL},
	 { "VEBCurrency_swigregister", VEBCurrency_swigregister, METH_O, NULL},
	 { "VEBCurrency_swiginit", VEBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_VNDCurrency", _wrap_new_VNDCurrency, METH_NOARGS, NULL},
	 { "delete_VNDCurrency", _wrap_delete_VNDCurrency, METH_O, NULL},
	 { "VNDCurrency_swigregister", VNDCurrency_swigregister, METH_O, NULL},
	 { "VNDCurrency_swiginit", VNDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ZARCurrency", _wrap_new_ZARCurrency, METH_NOARGS, NULL},
	 { "delete_ZARCurrency", _wrap_delete_ZARCurrency, METH_O, NULL},
	 { "ZARCurrency_swigregister", ZARCurrency_swigregister, METH_O, NULL},
	 { "ZARCurrency_swiginit", ZARCurrency_swiginit, METH_VARARGS, NULL},
	 { "Brent_setMaxEvaluations", _wrap_Brent_setMaxEvaluations, METH_VARARGS, NULL},
	 { "Brent_setLowerBound", _wrap_Brent_setLowerBound, METH_VARARGS, NULL},
	 { "Brent_setUpperBound", _wrap_Brent_setUpperBound, METH_VARARGS, NULL},
	 { "Brent_solve", _wrap_Brent_solve, METH_VARARGS, NULL},
	 { "new_Brent", _wrap_new_Brent, METH_NOARGS, NULL},
	 { "delete_Brent", _wrap_delete_Brent, METH_O, NULL},
	 { "Brent_swigregister", Brent_swigregister, METH_O, NULL},
	 { "Brent_swiginit", Brent_swiginit, METH_VARARGS, NULL},
	 { "Bisection_setMaxEvaluations", _wrap_Bisection_setMaxEvaluations, METH_VARARGS, NULL},
	 { "Bisection_setLowerBound", _wrap_Bisection_setLowerBound, METH_VARARGS, NULL},
	 { "Bisection_setUpperBound", _wrap_Bisection_setUpperBound, METH_VARARGS, NULL},
	 { "Bisection_solve", _wrap_Bisection_solve, METH_VARARGS, NULL},
	 { "new_Bisection", _wrap_new_Bisection, METH_NOARGS, NULL},
	 { "delete_Bisection", _wrap_delete_Bisection, METH_O, NULL},
	 { "Bisection_swigregister", Bisection_swigregister, METH_O, NULL},
	 { "Bisection_swiginit", Bisection_swiginit, METH_VARARGS, NULL},
	 { "FalsePosition_setMaxEvaluations", _wrap_FalsePosition_setMaxEvaluations, METH_VARARGS, NULL},
	 { "FalsePosition_setLowerBound", _wrap_FalsePosition_setLowerBound, METH_VARARGS, NULL},
	 { "FalsePosition_setUpperBound", _wrap_FalsePosition_setUpperBound, METH_VARARGS, NULL},
	 { "FalsePosition_solve", _wrap_FalsePosition_solve, METH_VARARGS, NULL},
	 { "new_FalsePosition", _wrap_new_FalsePosition, METH_NOARGS, NULL},
	 { "delete_FalsePosition", _wrap_delete_FalsePosition, METH_O, NULL},
	 { "FalsePosition_swigregister", FalsePosition_swigregister, METH_O, NULL},
	 { "FalsePosition_swiginit", FalsePosition_swiginit, METH_VARARGS, NULL},
	 { "Ridder_setMaxEvaluations", _wrap_Ridder_setMaxEvaluations, METH_VARARGS, NULL},
	 { "Ridder_setLowerBound", _wrap_Ridder_setLowerBound, METH_VARARGS, NULL},
	 { "Ridder_setUpperBound", _wrap_Ridder_setUpperBound, METH_VARARGS, NULL},
	 { "Ridder_solve", _wrap_Ridder_solve, METH_VARARGS, NULL},
	 { "new_Ridder", _wrap_new_Ridder, METH_NOARGS, NULL},
	 { "delete_Ridder", _wrap_delete_Ridder, METH_O, NULL},
	 { "Ridder_swigregister", Ridder_swigregister, METH_O, NULL},
	 { "Ridder_swiginit", Ridder_swiginit, METH_VARARGS, NULL},
	 { "Secant_setMaxEvaluations", _wrap_Secant_setMaxEvaluations, METH_VARARGS, NULL},
	 { "Secant_setLowerBound", _wrap_Secant_setLowerBound, METH_VARARGS, NULL},
	 { "Secant_setUpperBound", _wrap_Secant_setUpperBound, METH_VARARGS, NULL},
	 { "Secant_solve", _wrap_Secant_solve, METH_VARARGS, NULL},
	 { "new_Secant", _wrap_new_Secant, METH_NOARGS, NULL},
	 { "delete_Secant", _wrap_delete_Secant, METH_O, NULL},
	 { "Secant_swigregister", Secant_swigregister, METH_O, NULL},
	 { "Secant_swiginit", Secant_swiginit, METH_VARARGS, NULL},
	 { "Newton_setMaxEvaluations", _wrap_Newton_setMaxEvaluations, METH_VARARGS, NULL},
	 { "Newton_setLowerBound", _wrap_Newton_setLowerBound, METH_VARARGS, NULL},
	 { "Newton_setUpperBound", _wrap_Newton_setUpperBound, METH_VARARGS, NULL},
	 { "Newton_solve", _wrap_Newton_solve, METH_VARARGS, NULL},
	 { "new_Newton", _wrap_new_Newton, METH_NOARGS, NULL},
	 { "delete_Newton", _wrap_delete_Newton, METH_O, NULL},
	 { "Newton_swigregister", Newton_swigregister, METH_O, NULL},
	 { "Newton_swiginit", Newton_swiginit, METH_VARARGS, NULL},
	 { "NewtonSafe_setMaxEvaluations", _wrap_NewtonSafe_setMaxEvaluations, METH_VARARGS, NULL},
	 { "NewtonSafe_setLowerBound", _wrap_NewtonSafe_setLowerBound, METH_VARARGS, NULL},
	 { "NewtonSafe_setUpperBound", _wrap_NewtonSafe_setUpperBound, METH_VARARGS, NULL},
	 { "NewtonSafe_solve", _wrap_NewtonSafe_solve, METH_VARARGS, NULL},
	 { "new_NewtonSafe", _wrap_new_NewtonSafe, METH_NOARGS, NULL},
	 { "delete_NewtonSafe", _wrap_delete_NewtonSafe, METH_O, NULL},
	 { "NewtonSafe_swigregister", NewtonSafe_swigregister, METH_O, NULL},
	 { "NewtonSafe_swiginit", NewtonSafe_swiginit, METH_VARARGS, NULL},
	 { "delete_Constraint", _wrap_delete_Constraint, METH_O, NULL},
	 { "Constraint_swigregister", Constraint_swigregister, METH_O, NULL},
	 { "new_BoundaryConstraint", _wrap_new_BoundaryConstraint, METH_VARARGS, NULL},
	 { "delete_BoundaryConstraint", _wrap_delete_BoundaryConstraint, METH_O, NULL},
	 { "BoundaryConstraint_swigregister", BoundaryConstraint_swigregister, METH_O, NULL},
	 { "BoundaryConstraint_swiginit", BoundaryConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_NoConstraint", _wrap_new_NoConstraint, METH_NOARGS, NULL},
	 { "delete_NoConstraint", _wrap_delete_NoConstraint, METH_O, NULL},
	 { "NoConstraint_swigregister", NoConstraint_swigregister, METH_O, NULL},
	 { "NoConstraint_swiginit", NoConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_PositiveConstraint", _wrap_new_PositiveConstraint, METH_NOARGS, NULL},
	 { "delete_PositiveConstraint", _wrap_delete_PositiveConstraint, METH_O, NULL},
	 { "PositiveConstraint_swigregister", PositiveConstraint_swigregister, METH_O, NULL},
	 { "PositiveConstraint_swiginit", PositiveConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeConstraint", _wrap_new_CompositeConstraint, METH_VARARGS, NULL},
	 { "delete_CompositeConstraint", _wrap_delete_CompositeConstraint, METH_O, NULL},
	 { "CompositeConstraint_swigregister", CompositeConstraint_swigregister, METH_O, NULL},
	 { "CompositeConstraint_swiginit", CompositeConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_NonhomogeneousBoundaryConstraint", _wrap_new_NonhomogeneousBoundaryConstraint, METH_VARARGS, NULL},
	 { "delete_NonhomogeneousBoundaryConstraint", _wrap_delete_NonhomogeneousBoundaryConstraint, METH_O, NULL},
	 { "NonhomogeneousBoundaryConstraint_swigregister", NonhomogeneousBoundaryConstraint_swigregister, METH_O, NULL},
	 { "NonhomogeneousBoundaryConstraint_swiginit", NonhomogeneousBoundaryConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_EndCriteria", _wrap_new_EndCriteria, METH_VARARGS, NULL},
	 { "EndCriteria___call__", _wrap_EndCriteria___call__, METH_VARARGS, NULL},
	 { "delete_EndCriteria", _wrap_delete_EndCriteria, METH_O, NULL},
	 { "EndCriteria_swigregister", EndCriteria_swigregister, METH_O, NULL},
	 { "EndCriteria_swiginit", EndCriteria_swiginit, METH_VARARGS, NULL},
	 { "delete_OptimizationMethod", _wrap_delete_OptimizationMethod, METH_O, NULL},
	 { "OptimizationMethod_swigregister", OptimizationMethod_swigregister, METH_O, NULL},
	 { "new_ConjugateGradient", _wrap_new_ConjugateGradient, METH_NOARGS, NULL},
	 { "delete_ConjugateGradient", _wrap_delete_ConjugateGradient, METH_O, NULL},
	 { "ConjugateGradient_swigregister", ConjugateGradient_swigregister, METH_O, NULL},
	 { "ConjugateGradient_swiginit", ConjugateGradient_swiginit, METH_VARARGS, NULL},
	 { "new_Simplex", _wrap_new_Simplex, METH_O, NULL},
	 { "Simplex_getLambda", _wrap_Simplex_getLambda, METH_O, NULL},
	 { "delete_Simplex", _wrap_delete_Simplex, METH_O, NULL},
	 { "Simplex_swigregister", Simplex_swigregister, METH_O, NULL},
	 { "Simplex_swiginit", Simplex_swiginit, METH_VARARGS, NULL},
	 { "new_SteepestDescent", _wrap_new_SteepestDescent, METH_NOARGS, NULL},
	 { "delete_SteepestDescent", _wrap_delete_SteepestDescent, METH_O, NULL},
	 { "SteepestDescent_swigregister", SteepestDescent_swigregister, METH_O, NULL},
	 { "SteepestDescent_swiginit", SteepestDescent_swiginit, METH_VARARGS, NULL},
	 { "new_BFGS", _wrap_new_BFGS, METH_NOARGS, NULL},
	 { "delete_BFGS", _wrap_delete_BFGS, METH_O, NULL},
	 { "BFGS_swigregister", BFGS_swigregister, METH_O, NULL},
	 { "BFGS_swiginit", BFGS_swiginit, METH_VARARGS, NULL},
	 { "new_LevenbergMarquardt", _wrap_new_LevenbergMarquardt, METH_VARARGS, NULL},
	 { "delete_LevenbergMarquardt", _wrap_delete_LevenbergMarquardt, METH_O, NULL},
	 { "LevenbergMarquardt_swigregister", LevenbergMarquardt_swigregister, METH_O, NULL},
	 { "LevenbergMarquardt_swiginit", LevenbergMarquardt_swiginit, METH_VARARGS, NULL},
	 { "new_DifferentialEvolution", _wrap_new_DifferentialEvolution, METH_NOARGS, NULL},
	 { "delete_DifferentialEvolution", _wrap_delete_DifferentialEvolution, METH_O, NULL},
	 { "DifferentialEvolution_swigregister", DifferentialEvolution_swigregister, METH_O, NULL},
	 { "DifferentialEvolution_swiginit", DifferentialEvolution_swiginit, METH_VARARGS, NULL},
	 { "new_SamplerGaussian", _wrap_new_SamplerGaussian, METH_VARARGS, NULL},
	 { "delete_SamplerGaussian", _wrap_delete_SamplerGaussian, METH_O, NULL},
	 { "SamplerGaussian_swigregister", SamplerGaussian_swigregister, METH_O, NULL},
	 { "SamplerGaussian_swiginit", SamplerGaussian_swiginit, METH_VARARGS, NULL},
	 { "new_SamplerLogNormal", _wrap_new_SamplerLogNormal, METH_VARARGS, NULL},
	 { "delete_SamplerLogNormal", _wrap_delete_SamplerLogNormal, METH_O, NULL},
	 { "SamplerLogNormal_swigregister", SamplerLogNormal_swigregister, METH_O, NULL},
	 { "SamplerLogNormal_swiginit", SamplerLogNormal_swiginit, METH_VARARGS, NULL},
	 { "new_SamplerMirrorGaussian", _wrap_new_SamplerMirrorGaussian, METH_VARARGS, NULL},
	 { "delete_SamplerMirrorGaussian", _wrap_delete_SamplerMirrorGaussian, METH_O, NULL},
	 { "SamplerMirrorGaussian_swigregister", SamplerMirrorGaussian_swigregister, METH_O, NULL},
	 { "SamplerMirrorGaussian_swiginit", SamplerMirrorGaussian_swiginit, METH_VARARGS, NULL},
	 { "new_ProbabilityBoltzmannDownhill", _wrap_new_ProbabilityBoltzmannDownhill, METH_VARARGS, NULL},
	 { "delete_ProbabilityBoltzmannDownhill", _wrap_delete_ProbabilityBoltzmannDownhill, METH_O, NULL},
	 { "ProbabilityBoltzmannDownhill_swigregister", ProbabilityBoltzmannDownhill_swigregister, METH_O, NULL},
	 { "ProbabilityBoltzmannDownhill_swiginit", ProbabilityBoltzmannDownhill_swiginit, METH_VARARGS, NULL},
	 { "new_TemperatureExponential", _wrap_new_TemperatureExponential, METH_VARARGS, NULL},
	 { "delete_TemperatureExponential", _wrap_delete_TemperatureExponential, METH_O, NULL},
	 { "TemperatureExponential_swigregister", TemperatureExponential_swigregister, METH_O, NULL},
	 { "TemperatureExponential_swiginit", TemperatureExponential_swiginit, METH_VARARGS, NULL},
	 { "new_ReannealingTrivial", _wrap_new_ReannealingTrivial, METH_NOARGS, NULL},
	 { "delete_ReannealingTrivial", _wrap_delete_ReannealingTrivial, METH_O, NULL},
	 { "ReannealingTrivial_swigregister", ReannealingTrivial_swigregister, METH_O, NULL},
	 { "ReannealingTrivial_swiginit", ReannealingTrivial_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianSimulatedAnnealing", _wrap_new_GaussianSimulatedAnnealing, METH_VARARGS, NULL},
	 { "delete_GaussianSimulatedAnnealing", _wrap_delete_GaussianSimulatedAnnealing, METH_O, NULL},
	 { "GaussianSimulatedAnnealing_swigregister", GaussianSimulatedAnnealing_swigregister, METH_O, NULL},
	 { "GaussianSimulatedAnnealing_swiginit", GaussianSimulatedAnnealing_swiginit, METH_VARARGS, NULL},
	 { "new_MirrorGaussianSimulatedAnnealing", _wrap_new_MirrorGaussianSimulatedAnnealing, METH_VARARGS, NULL},
	 { "delete_MirrorGaussianSimulatedAnnealing", _wrap_delete_MirrorGaussianSimulatedAnnealing, METH_O, NULL},
	 { "MirrorGaussianSimulatedAnnealing_swigregister", MirrorGaussianSimulatedAnnealing_swigregister, METH_O, NULL},
	 { "MirrorGaussianSimulatedAnnealing_swiginit", MirrorGaussianSimulatedAnnealing_swiginit, METH_VARARGS, NULL},
	 { "new_LogNormalSimulatedAnnealing", _wrap_new_LogNormalSimulatedAnnealing, METH_VARARGS, NULL},
	 { "delete_LogNormalSimulatedAnnealing", _wrap_delete_LogNormalSimulatedAnnealing, METH_O, NULL},
	 { "LogNormalSimulatedAnnealing_swigregister", LogNormalSimulatedAnnealing_swigregister, METH_O, NULL},
	 { "LogNormalSimulatedAnnealing_swiginit", LogNormalSimulatedAnnealing_swiginit, METH_VARARGS, NULL},
	 { "Optimizer_solve", _wrap_Optimizer_solve, METH_VARARGS, NULL},
	 { "new_Optimizer", _wrap_new_Optimizer, METH_NOARGS, NULL},
	 { "delete_Optimizer", _wrap_delete_Optimizer, METH_O, NULL},
	 { "Optimizer_swigregister", Optimizer_swigregister, METH_O, NULL},
	 { "Optimizer_swiginit", Optimizer_swiginit, METH_VARARGS, NULL},
	 { "new_LinearInterpolation", _wrap_new_LinearInterpolation, METH_VARARGS, NULL},
	 { "LinearInterpolation___call__", _wrap_LinearInterpolation___call__, METH_VARARGS, NULL},
	 { "delete_LinearInterpolation", _wrap_delete_LinearInterpolation, METH_O, NULL},
	 { "LinearInterpolation_swigregister", LinearInterpolation_swigregister, METH_O, NULL},
	 { "LinearInterpolation_swiginit", LinearInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_LogLinearInterpolation", _wrap_new_LogLinearInterpolation, METH_VARARGS, NULL},
	 { "LogLinearInterpolation___call__", _wrap_LogLinearInterpolation___call__, METH_VARARGS, NULL},
	 { "delete_LogLinearInterpolation", _wrap_delete_LogLinearInterpolation, METH_O, NULL},
	 { "LogLinearInterpolation_swigregister", LogLinearInterpolation_swigregister, METH_O, NULL},
	 { "LogLinearInterpolation_swiginit", LogLinearInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_BackwardFlatInterpolation", _wrap_new_BackwardFlatInterpolation, METH_VARARGS, NULL},
	 { "BackwardFlatInterpolation___call__", _wrap_BackwardFlatInterpolation___call__, METH_VARARGS, NULL},
	 { "delete_BackwardFlatInterpolation", _wrap_delete_BackwardFlatInterpolation, METH_O, NULL},
	 { "BackwardFlatInterpolation_swigregister", BackwardFlatInterpolation_swigregister, METH_O, NULL},
	 { "BackwardFlatInterpolation_swiginit", BackwardFlatInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardFlatInterpolation", _wrap_new_ForwardFlatInterpolation, METH_VARARGS, NULL},
	 { "ForwardFlatInterpolation___call__", _wrap_ForwardFlatInterpolation___call__, METH_VARARGS, NULL},
	 { "delete_ForwardFlatInterpolation", _wrap_delete_ForwardFlatInterpolation, METH_O, NULL},
	 { "ForwardFlatInterpolation_swigregister", ForwardFlatInterpolation_swigregister, METH_O, NULL},
	 { "ForwardFlatInterpolation_swiginit", ForwardFlatInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_CubicNaturalSpline", _wrap_new_CubicNaturalSpline, METH_VARARGS, NULL},
	 { "CubicNaturalSpline___call__", _wrap_CubicNaturalSpline___call__, METH_VARARGS, NULL},
	 { "CubicNaturalSpline_derivative", _wrap_CubicNaturalSpline_derivative, METH_VARARGS, NULL},
	 { "CubicNaturalSpline_secondDerivative", _wrap_CubicNaturalSpline_secondDerivative, METH_VARARGS, NULL},
	 { "CubicNaturalSpline_primitive", _wrap_CubicNaturalSpline_primitive, METH_VARARGS, NULL},
	 { "delete_CubicNaturalSpline", _wrap_delete_CubicNaturalSpline, METH_O, NULL},
	 { "CubicNaturalSpline_swigregister", CubicNaturalSpline_swigregister, METH_O, NULL},
	 { "CubicNaturalSpline_swiginit", CubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_LogCubicNaturalSpline", _wrap_new_LogCubicNaturalSpline, METH_VARARGS, NULL},
	 { "LogCubicNaturalSpline___call__", _wrap_LogCubicNaturalSpline___call__, METH_VARARGS, NULL},
	 { "LogCubicNaturalSpline_derivative", _wrap_LogCubicNaturalSpline_derivative, METH_VARARGS, NULL},
	 { "LogCubicNaturalSpline_secondDerivative", _wrap_LogCubicNaturalSpline_secondDerivative, METH_VARARGS, NULL},
	 { "LogCubicNaturalSpline_primitive", _wrap_LogCubicNaturalSpline_primitive, METH_VARARGS, NULL},
	 { "delete_LogCubicNaturalSpline", _wrap_delete_LogCubicNaturalSpline, METH_O, NULL},
	 { "LogCubicNaturalSpline_swigregister", LogCubicNaturalSpline_swigregister, METH_O, NULL},
	 { "LogCubicNaturalSpline_swiginit", LogCubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubicNaturalSpline", _wrap_new_MonotonicCubicNaturalSpline, METH_VARARGS, NULL},
	 { "MonotonicCubicNaturalSpline___call__", _wrap_MonotonicCubicNaturalSpline___call__, METH_VARARGS, NULL},
	 { "MonotonicCubicNaturalSpline_derivative", _wrap_MonotonicCubicNaturalSpline_derivative, METH_VARARGS, NULL},
	 { "MonotonicCubicNaturalSpline_secondDerivative", _wrap_MonotonicCubicNaturalSpline_secondDerivative, METH_VARARGS, NULL},
	 { "MonotonicCubicNaturalSpline_primitive", _wrap_MonotonicCubicNaturalSpline_primitive, METH_VARARGS, NULL},
	 { "delete_MonotonicCubicNaturalSpline", _wrap_delete_MonotonicCubicNaturalSpline, METH_O, NULL},
	 { "MonotonicCubicNaturalSpline_swigregister", MonotonicCubicNaturalSpline_swigregister, METH_O, NULL},
	 { "MonotonicCubicNaturalSpline_swiginit", MonotonicCubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogCubicNaturalSpline", _wrap_new_MonotonicLogCubicNaturalSpline, METH_VARARGS, NULL},
	 { "MonotonicLogCubicNaturalSpline___call__", _wrap_MonotonicLogCubicNaturalSpline___call__, METH_VARARGS, NULL},
	 { "MonotonicLogCubicNaturalSpline_derivative", _wrap_MonotonicLogCubicNaturalSpline_derivative, METH_VARARGS, NULL},
	 { "MonotonicLogCubicNaturalSpline_secondDerivative", _wrap_MonotonicLogCubicNaturalSpline_secondDerivative, METH_VARARGS, NULL},
	 { "MonotonicLogCubicNaturalSpline_primitive", _wrap_MonotonicLogCubicNaturalSpline_primitive, METH_VARARGS, NULL},
	 { "delete_MonotonicLogCubicNaturalSpline", _wrap_delete_MonotonicLogCubicNaturalSpline, METH_O, NULL},
	 { "MonotonicLogCubicNaturalSpline_swigregister", MonotonicLogCubicNaturalSpline_swigregister, METH_O, NULL},
	 { "MonotonicLogCubicNaturalSpline_swiginit", MonotonicLogCubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerCubic", _wrap_new_KrugerCubic, METH_VARARGS, NULL},
	 { "KrugerCubic___call__", _wrap_KrugerCubic___call__, METH_VARARGS, NULL},
	 { "KrugerCubic_derivative", _wrap_KrugerCubic_derivative, METH_VARARGS, NULL},
	 { "KrugerCubic_secondDerivative", _wrap_KrugerCubic_secondDerivative, METH_VARARGS, NULL},
	 { "KrugerCubic_primitive", _wrap_KrugerCubic_primitive, METH_VARARGS, NULL},
	 { "delete_KrugerCubic", _wrap_delete_KrugerCubic, METH_O, NULL},
	 { "KrugerCubic_swigregister", KrugerCubic_swigregister, METH_O, NULL},
	 { "KrugerCubic_swiginit", KrugerCubic_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerLogCubic", _wrap_new_KrugerLogCubic, METH_VARARGS, NULL},
	 { "KrugerLogCubic___call__", _wrap_KrugerLogCubic___call__, METH_VARARGS, NULL},
	 { "KrugerLogCubic_derivative", _wrap_KrugerLogCubic_derivative, METH_VARARGS, NULL},
	 { "KrugerLogCubic_secondDerivative", _wrap_KrugerLogCubic_secondDerivative, METH_VARARGS, NULL},
	 { "KrugerLogCubic_primitive", _wrap_KrugerLogCubic_primitive, METH_VARARGS, NULL},
	 { "delete_KrugerLogCubic", _wrap_delete_KrugerLogCubic, METH_O, NULL},
	 { "KrugerLogCubic_swigregister", KrugerLogCubic_swigregister, METH_O, NULL},
	 { "KrugerLogCubic_swiginit", KrugerLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_FritschButlandCubic", _wrap_new_FritschButlandCubic, METH_VARARGS, NULL},
	 { "FritschButlandCubic___call__", _wrap_FritschButlandCubic___call__, METH_VARARGS, NULL},
	 { "FritschButlandCubic_derivative", _wrap_FritschButlandCubic_derivative, METH_VARARGS, NULL},
	 { "FritschButlandCubic_secondDerivative", _wrap_FritschButlandCubic_secondDerivative, METH_VARARGS, NULL},
	 { "FritschButlandCubic_primitive", _wrap_FritschButlandCubic_primitive, METH_VARARGS, NULL},
	 { "delete_FritschButlandCubic", _wrap_delete_FritschButlandCubic, METH_O, NULL},
	 { "FritschButlandCubic_swigregister", FritschButlandCubic_swigregister, METH_O, NULL},
	 { "FritschButlandCubic_swiginit", FritschButlandCubic_swiginit, METH_VARARGS, NULL},
	 { "new_FritschButlandLogCubic", _wrap_new_FritschButlandLogCubic, METH_VARARGS, NULL},
	 { "FritschButlandLogCubic___call__", _wrap_FritschButlandLogCubic___call__, METH_VARARGS, NULL},
	 { "FritschButlandLogCubic_derivative", _wrap_FritschButlandLogCubic_derivative, METH_VARARGS, NULL},
	 { "FritschButlandLogCubic_secondDerivative", _wrap_FritschButlandLogCubic_secondDerivative, METH_VARARGS, NULL},
	 { "FritschButlandLogCubic_primitive", _wrap_FritschButlandLogCubic_primitive, METH_VARARGS, NULL},
	 { "delete_FritschButlandLogCubic", _wrap_delete_FritschButlandLogCubic, METH_O, NULL},
	 { "FritschButlandLogCubic_swigregister", FritschButlandLogCubic_swigregister, METH_O, NULL},
	 { "FritschButlandLogCubic_swiginit", FritschButlandLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_Parabolic", _wrap_new_Parabolic, METH_VARARGS, NULL},
	 { "Parabolic___call__", _wrap_Parabolic___call__, METH_VARARGS, NULL},
	 { "Parabolic_derivative", _wrap_Parabolic_derivative, METH_VARARGS, NULL},
	 { "Parabolic_secondDerivative", _wrap_Parabolic_secondDerivative, METH_VARARGS, NULL},
	 { "Parabolic_primitive", _wrap_Parabolic_primitive, METH_VARARGS, NULL},
	 { "delete_Parabolic", _wrap_delete_Parabolic, METH_O, NULL},
	 { "Parabolic_swigregister", Parabolic_swigregister, METH_O, NULL},
	 { "Parabolic_swiginit", Parabolic_swiginit, METH_VARARGS, NULL},
	 { "new_LogParabolic", _wrap_new_LogParabolic, METH_VARARGS, NULL},
	 { "LogParabolic___call__", _wrap_LogParabolic___call__, METH_VARARGS, NULL},
	 { "LogParabolic_derivative", _wrap_LogParabolic_derivative, METH_VARARGS, NULL},
	 { "LogParabolic_secondDerivative", _wrap_LogParabolic_secondDerivative, METH_VARARGS, NULL},
	 { "LogParabolic_primitive", _wrap_LogParabolic_primitive, METH_VARARGS, NULL},
	 { "delete_LogParabolic", _wrap_delete_LogParabolic, METH_O, NULL},
	 { "LogParabolic_swigregister", LogParabolic_swigregister, METH_O, NULL},
	 { "LogParabolic_swiginit", LogParabolic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicParabolic", _wrap_new_MonotonicParabolic, METH_VARARGS, NULL},
	 { "MonotonicParabolic___call__", _wrap_MonotonicParabolic___call__, METH_VARARGS, NULL},
	 { "MonotonicParabolic_derivative", _wrap_MonotonicParabolic_derivative, METH_VARARGS, NULL},
	 { "MonotonicParabolic_secondDerivative", _wrap_MonotonicParabolic_secondDerivative, METH_VARARGS, NULL},
	 { "MonotonicParabolic_primitive", _wrap_MonotonicParabolic_primitive, METH_VARARGS, NULL},
	 { "delete_MonotonicParabolic", _wrap_delete_MonotonicParabolic, METH_O, NULL},
	 { "MonotonicParabolic_swigregister", MonotonicParabolic_swigregister, METH_O, NULL},
	 { "MonotonicParabolic_swiginit", MonotonicParabolic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogParabolic", _wrap_new_MonotonicLogParabolic, METH_VARARGS, NULL},
	 { "MonotonicLogParabolic___call__", _wrap_MonotonicLogParabolic___call__, METH_VARARGS, NULL},
	 { "MonotonicLogParabolic_derivative", _wrap_MonotonicLogParabolic_derivative, METH_VARARGS, NULL},
	 { "MonotonicLogParabolic_secondDerivative", _wrap_MonotonicLogParabolic_secondDerivative, METH_VARARGS, NULL},
	 { "MonotonicLogParabolic_primitive", _wrap_MonotonicLogParabolic_primitive, METH_VARARGS, NULL},
	 { "delete_MonotonicLogParabolic", _wrap_delete_MonotonicLogParabolic, METH_O, NULL},
	 { "MonotonicLogParabolic_swigregister", MonotonicLogParabolic_swigregister, METH_O, NULL},
	 { "MonotonicLogParabolic_swiginit", MonotonicLogParabolic_swiginit, METH_VARARGS, NULL},
	 { "new_BilinearInterpolation", _wrap_new_BilinearInterpolation, METH_VARARGS, NULL},
	 { "BilinearInterpolation___call__", _wrap_BilinearInterpolation___call__, METH_VARARGS, NULL},
	 { "delete_BilinearInterpolation", _wrap_delete_BilinearInterpolation, METH_O, NULL},
	 { "BilinearInterpolation_swigregister", BilinearInterpolation_swigregister, METH_O, NULL},
	 { "BilinearInterpolation_swiginit", BilinearInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_BicubicSpline", _wrap_new_BicubicSpline, METH_VARARGS, NULL},
	 { "BicubicSpline___call__", _wrap_BicubicSpline___call__, METH_VARARGS, NULL},
	 { "delete_BicubicSpline", _wrap_delete_BicubicSpline, METH_O, NULL},
	 { "BicubicSpline_swigregister", BicubicSpline_swigregister, METH_O, NULL},
	 { "BicubicSpline_swiginit", BicubicSpline_swiginit, METH_VARARGS, NULL},
	 { "new_BackwardFlat", _wrap_new_BackwardFlat, METH_NOARGS, NULL},
	 { "delete_BackwardFlat", _wrap_delete_BackwardFlat, METH_O, NULL},
	 { "BackwardFlat_swigregister", BackwardFlat_swigregister, METH_O, NULL},
	 { "BackwardFlat_swiginit", BackwardFlat_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardFlat", _wrap_new_ForwardFlat, METH_NOARGS, NULL},
	 { "delete_ForwardFlat", _wrap_delete_ForwardFlat, METH_O, NULL},
	 { "ForwardFlat_swigregister", ForwardFlat_swigregister, METH_O, NULL},
	 { "ForwardFlat_swiginit", ForwardFlat_swiginit, METH_VARARGS, NULL},
	 { "new_Linear", _wrap_new_Linear, METH_NOARGS, NULL},
	 { "delete_Linear", _wrap_delete_Linear, METH_O, NULL},
	 { "Linear_swigregister", Linear_swigregister, METH_O, NULL},
	 { "Linear_swiginit", Linear_swiginit, METH_VARARGS, NULL},
	 { "new_LogLinear", _wrap_new_LogLinear, METH_NOARGS, NULL},
	 { "delete_LogLinear", _wrap_delete_LogLinear, METH_O, NULL},
	 { "LogLinear_swigregister", LogLinear_swigregister, METH_O, NULL},
	 { "LogLinear_swiginit", LogLinear_swiginit, METH_VARARGS, NULL},
	 { "new_Cubic", _wrap_new_Cubic, METH_NOARGS, NULL},
	 { "delete_Cubic", _wrap_delete_Cubic, METH_O, NULL},
	 { "Cubic_swigregister", Cubic_swigregister, METH_O, NULL},
	 { "Cubic_swiginit", Cubic_swiginit, METH_VARARGS, NULL},
	 { "new_Bicubic", _wrap_new_Bicubic, METH_NOARGS, NULL},
	 { "delete_Bicubic", _wrap_delete_Bicubic, METH_O, NULL},
	 { "Bicubic_swigregister", Bicubic_swigregister, METH_O, NULL},
	 { "Bicubic_swiginit", Bicubic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubic", _wrap_new_MonotonicCubic, METH_NOARGS, NULL},
	 { "delete_MonotonicCubic", _wrap_delete_MonotonicCubic, METH_O, NULL},
	 { "MonotonicCubic_swigregister", MonotonicCubic_swigregister, METH_O, NULL},
	 { "MonotonicCubic_swiginit", MonotonicCubic_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultLogCubic", _wrap_new_DefaultLogCubic, METH_NOARGS, NULL},
	 { "delete_DefaultLogCubic", _wrap_delete_DefaultLogCubic, METH_O, NULL},
	 { "DefaultLogCubic_swigregister", DefaultLogCubic_swigregister, METH_O, NULL},
	 { "DefaultLogCubic_swiginit", DefaultLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogCubic", _wrap_new_MonotonicLogCubic, METH_NOARGS, NULL},
	 { "delete_MonotonicLogCubic", _wrap_delete_MonotonicLogCubic, METH_O, NULL},
	 { "MonotonicLogCubic_swigregister", MonotonicLogCubic_swigregister, METH_O, NULL},
	 { "MonotonicLogCubic_swiginit", MonotonicLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_SplineCubic", _wrap_new_SplineCubic, METH_NOARGS, NULL},
	 { "delete_SplineCubic", _wrap_delete_SplineCubic, METH_O, NULL},
	 { "SplineCubic_swigregister", SplineCubic_swigregister, METH_O, NULL},
	 { "SplineCubic_swiginit", SplineCubic_swiginit, METH_VARARGS, NULL},
	 { "new_Kruger", _wrap_new_Kruger, METH_NOARGS, NULL},
	 { "delete_Kruger", _wrap_delete_Kruger, METH_O, NULL},
	 { "Kruger_swigregister", Kruger_swigregister, METH_O, NULL},
	 { "Kruger_swiginit", Kruger_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerLog", _wrap_new_KrugerLog, METH_NOARGS, NULL},
	 { "delete_KrugerLog", _wrap_delete_KrugerLog, METH_O, NULL},
	 { "KrugerLog_swigregister", KrugerLog_swigregister, METH_O, NULL},
	 { "KrugerLog_swiginit", KrugerLog_swiginit, METH_VARARGS, NULL},
	 { "new_ConvexMonotone", _wrap_new_ConvexMonotone, METH_VARARGS, NULL},
	 { "delete_ConvexMonotone", _wrap_delete_ConvexMonotone, METH_O, NULL},
	 { "ConvexMonotone_swigregister", ConvexMonotone_swigregister, METH_O, NULL},
	 { "ConvexMonotone_swiginit", ConvexMonotone_swiginit, METH_VARARGS, NULL},
	 { "new_SABRInterpolation", _wrap_new_SABRInterpolation, METH_VARARGS, NULL},
	 { "SABRInterpolation___call__", _wrap_SABRInterpolation___call__, METH_VARARGS, NULL},
	 { "SABRInterpolation_alpha", _wrap_SABRInterpolation_alpha, METH_O, NULL},
	 { "SABRInterpolation_beta", _wrap_SABRInterpolation_beta, METH_O, NULL},
	 { "SABRInterpolation_rho", _wrap_SABRInterpolation_rho, METH_O, NULL},
	 { "SABRInterpolation_nu", _wrap_SABRInterpolation_nu, METH_O, NULL},
	 { "delete_SABRInterpolation", _wrap_delete_SABRInterpolation, METH_O, NULL},
	 { "SABRInterpolation_swigregister", SABRInterpolation_swigregister, METH_O, NULL},
	 { "SABRInterpolation_swiginit", SABRInterpolation_swiginit, METH_VARARGS, NULL},
	 { "RichardsonExtrapolation___call__", _wrap_RichardsonExtrapolation___call__, METH_VARARGS, NULL},
	 { "new_RichardsonExtrapolation", _wrap_new_RichardsonExtrapolation, METH_VARARGS, NULL},
	 { "delete_RichardsonExtrapolation", _wrap_delete_RichardsonExtrapolation, METH_O, NULL},
	 { "RichardsonExtrapolation_swigregister", RichardsonExtrapolation_swigregister, METH_O, NULL},
	 { "RichardsonExtrapolation_swiginit", RichardsonExtrapolation_swiginit, METH_VARARGS, NULL},
	 { "new_ConvexMonotoneInterpolation", _wrap_new_ConvexMonotoneInterpolation, METH_VARARGS, NULL},
	 { "ConvexMonotoneInterpolation___call__", _wrap_ConvexMonotoneInterpolation___call__, METH_VARARGS, NULL},
	 { "delete_ConvexMonotoneInterpolation", _wrap_delete_ConvexMonotoneInterpolation, METH_O, NULL},
	 { "ConvexMonotoneInterpolation_swigregister", ConvexMonotoneInterpolation_swigregister, METH_O, NULL},
	 { "ConvexMonotoneInterpolation_swiginit", ConvexMonotoneInterpolation_swiginit, METH_VARARGS, NULL},
	 { "TermStructure_dayCounter", _wrap_TermStructure_dayCounter, METH_O, NULL},
	 { "TermStructure_timeFromReference", _wrap_TermStructure_timeFromReference, METH_VARARGS, NULL},
	 { "TermStructure_calendar", _wrap_TermStructure_calendar, METH_O, NULL},
	 { "TermStructure_referenceDate", _wrap_TermStructure_referenceDate, METH_O, NULL},
	 { "TermStructure_maxDate", _wrap_TermStructure_maxDate, METH_O, NULL},
	 { "TermStructure_maxTime", _wrap_TermStructure_maxTime, METH_O, NULL},
	 { "TermStructure_enableExtrapolation", _wrap_TermStructure_enableExtrapolation, METH_O, NULL},
	 { "TermStructure_disableExtrapolation", _wrap_TermStructure_disableExtrapolation, METH_O, NULL},
	 { "TermStructure_allowsExtrapolation", _wrap_TermStructure_allowsExtrapolation, METH_O, NULL},
	 { "delete_TermStructure", _wrap_delete_TermStructure, METH_O, NULL},
	 { "TermStructure_swigregister", TermStructure_swigregister, METH_O, NULL},
	 { "YieldTermStructure_discount", _wrap_YieldTermStructure_discount, METH_VARARGS, NULL},
	 { "YieldTermStructure_zeroRate", _wrap_YieldTermStructure_zeroRate, METH_VARARGS, NULL},
	 { "YieldTermStructure_forwardRate", _wrap_YieldTermStructure_forwardRate, METH_VARARGS, NULL},
	 { "delete_YieldTermStructure", _wrap_delete_YieldTermStructure, METH_O, NULL},
	 { "YieldTermStructure_swigregister", YieldTermStructure_swigregister, METH_O, NULL},
	 { "new_YieldTermStructureHandle", _wrap_new_YieldTermStructureHandle, METH_VARARGS, NULL},
	 { "YieldTermStructureHandle___deref__", _wrap_YieldTermStructureHandle___deref__, METH_O, NULL},
	 { "YieldTermStructureHandle_currentLink", _wrap_YieldTermStructureHandle_currentLink, METH_O, NULL},
	 { "YieldTermStructureHandle___nonzero__", _wrap_YieldTermStructureHandle___nonzero__, METH_O, NULL},
	 { "YieldTermStructureHandle___bool__", _wrap_YieldTermStructureHandle___bool__, METH_O, NULL},
	 { "YieldTermStructureHandle_asObservable", _wrap_YieldTermStructureHandle_asObservable, METH_O, NULL},
	 { "delete_YieldTermStructureHandle", _wrap_delete_YieldTermStructureHandle, METH_O, NULL},
	 { "YieldTermStructureHandle_discount", _wrap_YieldTermStructureHandle_discount, METH_VARARGS, NULL},
	 { "YieldTermStructureHandle_zeroRate", _wrap_YieldTermStructureHandle_zeroRate, METH_VARARGS, NULL},
	 { "YieldTermStructureHandle_forwardRate", _wrap_YieldTermStructureHandle_forwardRate, METH_VARARGS, NULL},
	 { "YieldTermStructureHandle_dayCounter", _wrap_YieldTermStructureHandle_dayCounter, METH_O, NULL},
	 { "YieldTermStructureHandle_timeFromReference", _wrap_YieldTermStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "YieldTermStructureHandle_calendar", _wrap_YieldTermStructureHandle_calendar, METH_O, NULL},
	 { "YieldTermStructureHandle_referenceDate", _wrap_YieldTermStructureHandle_referenceDate, METH_O, NULL},
	 { "YieldTermStructureHandle_maxDate", _wrap_YieldTermStructureHandle_maxDate, METH_O, NULL},
	 { "YieldTermStructureHandle_maxTime", _wrap_YieldTermStructureHandle_maxTime, METH_O, NULL},
	 { "YieldTermStructureHandle_enableExtrapolation", _wrap_YieldTermStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "YieldTermStructureHandle_disableExtrapolation", _wrap_YieldTermStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "YieldTermStructureHandle_allowsExtrapolation", _wrap_YieldTermStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "YieldTermStructureHandle_swigregister", YieldTermStructureHandle_swigregister, METH_O, NULL},
	 { "YieldTermStructureHandle_swiginit", YieldTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableYieldTermStructureHandle", _wrap_new_RelinkableYieldTermStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableYieldTermStructureHandle_linkTo", _wrap_RelinkableYieldTermStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableYieldTermStructureHandle_reset", _wrap_RelinkableYieldTermStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableYieldTermStructureHandle", _wrap_delete_RelinkableYieldTermStructureHandle, METH_O, NULL},
	 { "RelinkableYieldTermStructureHandle_swigregister", RelinkableYieldTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableYieldTermStructureHandle_swiginit", RelinkableYieldTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_ImpliedTermStructure", _wrap_new_ImpliedTermStructure, METH_VARARGS, NULL},
	 { "delete_ImpliedTermStructure", _wrap_delete_ImpliedTermStructure, METH_O, NULL},
	 { "ImpliedTermStructure_swigregister", ImpliedTermStructure_swigregister, METH_O, NULL},
	 { "ImpliedTermStructure_swiginit", ImpliedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroSpreadedTermStructure", _wrap_new_ZeroSpreadedTermStructure, METH_VARARGS, NULL},
	 { "delete_ZeroSpreadedTermStructure", _wrap_delete_ZeroSpreadedTermStructure, METH_O, NULL},
	 { "ZeroSpreadedTermStructure_swigregister", ZeroSpreadedTermStructure_swigregister, METH_O, NULL},
	 { "ZeroSpreadedTermStructure_swiginit", ZeroSpreadedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardSpreadedTermStructure", _wrap_new_ForwardSpreadedTermStructure, METH_VARARGS, NULL},
	 { "delete_ForwardSpreadedTermStructure", _wrap_delete_ForwardSpreadedTermStructure, METH_O, NULL},
	 { "ForwardSpreadedTermStructure_swigregister", ForwardSpreadedTermStructure_swigregister, METH_O, NULL},
	 { "ForwardSpreadedTermStructure_swiginit", ForwardSpreadedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadedLinearZeroInterpolatedTermStructure", _wrap_new_SpreadedLinearZeroInterpolatedTermStructure, METH_VARARGS, NULL},
	 { "delete_SpreadedLinearZeroInterpolatedTermStructure", _wrap_delete_SpreadedLinearZeroInterpolatedTermStructure, METH_O, NULL},
	 { "SpreadedLinearZeroInterpolatedTermStructure_swigregister", SpreadedLinearZeroInterpolatedTermStructure_swigregister, METH_O, NULL},
	 { "SpreadedLinearZeroInterpolatedTermStructure_swiginit", SpreadedLinearZeroInterpolatedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadedBackwardFlatZeroInterpolatedTermStructure", _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure, METH_VARARGS, NULL},
	 { "delete_SpreadedBackwardFlatZeroInterpolatedTermStructure", _wrap_delete_SpreadedBackwardFlatZeroInterpolatedTermStructure, METH_O, NULL},
	 { "SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister", SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister, METH_O, NULL},
	 { "SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit", SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_FlatForward", _wrap_new_FlatForward, METH_VARARGS, NULL},
	 { "delete_FlatForward", _wrap_delete_FlatForward, METH_O, NULL},
	 { "FlatForward_swigregister", FlatForward_swigregister, METH_O, NULL},
	 { "FlatForward_swiginit", FlatForward_swiginit, METH_VARARGS, NULL},
	 { "new_RealTimeSeries", _wrap_new_RealTimeSeries, METH_VARARGS, NULL},
	 { "RealTimeSeries_dates", _wrap_RealTimeSeries_dates, METH_O, NULL},
	 { "RealTimeSeries_values", _wrap_RealTimeSeries_values, METH_O, NULL},
	 { "RealTimeSeries___len__", _wrap_RealTimeSeries___len__, METH_O, NULL},
	 { "RealTimeSeries___getitem__", _wrap_RealTimeSeries___getitem__, METH_VARARGS, NULL},
	 { "RealTimeSeries___setitem__", _wrap_RealTimeSeries___setitem__, METH_VARARGS, NULL},
	 { "delete_RealTimeSeries", _wrap_delete_RealTimeSeries, METH_O, NULL},
	 { "RealTimeSeries_swigregister", RealTimeSeries_swigregister, METH_O, NULL},
	 { "RealTimeSeries_swiginit", RealTimeSeries_swiginit, METH_VARARGS, NULL},
	 { "new_IntervalPriceTimeSeries", _wrap_new_IntervalPriceTimeSeries, METH_VARARGS, NULL},
	 { "IntervalPriceTimeSeries_dates", _wrap_IntervalPriceTimeSeries_dates, METH_O, NULL},
	 { "IntervalPriceTimeSeries_values", _wrap_IntervalPriceTimeSeries_values, METH_O, NULL},
	 { "IntervalPriceTimeSeries___len__", _wrap_IntervalPriceTimeSeries___len__, METH_O, NULL},
	 { "IntervalPriceTimeSeries___getitem__", _wrap_IntervalPriceTimeSeries___getitem__, METH_VARARGS, NULL},
	 { "IntervalPriceTimeSeries___setitem__", _wrap_IntervalPriceTimeSeries___setitem__, METH_VARARGS, NULL},
	 { "delete_IntervalPriceTimeSeries", _wrap_delete_IntervalPriceTimeSeries, METH_O, NULL},
	 { "IntervalPriceTimeSeries_swigregister", IntervalPriceTimeSeries_swigregister, METH_O, NULL},
	 { "IntervalPriceTimeSeries_swiginit", IntervalPriceTimeSeries_swiginit, METH_VARARGS, NULL},
	 { "IntervalPriceVector_iterator", _wrap_IntervalPriceVector_iterator, METH_O, NULL},
	 { "IntervalPriceVector___nonzero__", _wrap_IntervalPriceVector___nonzero__, METH_O, NULL},
	 { "IntervalPriceVector___bool__", _wrap_IntervalPriceVector___bool__, METH_O, NULL},
	 { "IntervalPriceVector___len__", _wrap_IntervalPriceVector___len__, METH_O, NULL},
	 { "IntervalPriceVector___getslice__", _wrap_IntervalPriceVector___getslice__, METH_VARARGS, NULL},
	 { "IntervalPriceVector___setslice__", _wrap_IntervalPriceVector___setslice__, METH_VARARGS, NULL},
	 { "IntervalPriceVector___delslice__", _wrap_IntervalPriceVector___delslice__, METH_VARARGS, NULL},
	 { "IntervalPriceVector___delitem__", _wrap_IntervalPriceVector___delitem__, METH_VARARGS, NULL},
	 { "IntervalPriceVector___getitem__", _wrap_IntervalPriceVector___getitem__, METH_VARARGS, NULL},
	 { "IntervalPriceVector___setitem__", _wrap_IntervalPriceVector___setitem__, METH_VARARGS, NULL},
	 { "IntervalPriceVector_pop", _wrap_IntervalPriceVector_pop, METH_O, NULL},
	 { "IntervalPriceVector_append", _wrap_IntervalPriceVector_append, METH_VARARGS, NULL},
	 { "IntervalPriceVector_empty", _wrap_IntervalPriceVector_empty, METH_O, NULL},
	 { "IntervalPriceVector_size", _wrap_IntervalPriceVector_size, METH_O, NULL},
	 { "IntervalPriceVector_swap", _wrap_IntervalPriceVector_swap, METH_VARARGS, NULL},
	 { "IntervalPriceVector_begin", _wrap_IntervalPriceVector_begin, METH_O, NULL},
	 { "IntervalPriceVector_end", _wrap_IntervalPriceVector_end, METH_O, NULL},
	 { "IntervalPriceVector_rbegin", _wrap_IntervalPriceVector_rbegin, METH_O, NULL},
	 { "IntervalPriceVector_rend", _wrap_IntervalPriceVector_rend, METH_O, NULL},
	 { "IntervalPriceVector_clear", _wrap_IntervalPriceVector_clear, METH_O, NULL},
	 { "IntervalPriceVector_get_allocator", _wrap_IntervalPriceVector_get_allocator, METH_O, NULL},
	 { "IntervalPriceVector_pop_back", _wrap_IntervalPriceVector_pop_back, METH_O, NULL},
	 { "IntervalPriceVector_erase", _wrap_IntervalPriceVector_erase, METH_VARARGS, NULL},
	 { "new_IntervalPriceVector", _wrap_new_IntervalPriceVector, METH_VARARGS, NULL},
	 { "IntervalPriceVector_push_back", _wrap_IntervalPriceVector_push_back, METH_VARARGS, NULL},
	 { "IntervalPriceVector_front", _wrap_IntervalPriceVector_front, METH_O, NULL},
	 { "IntervalPriceVector_back", _wrap_IntervalPriceVector_back, METH_O, NULL},
	 { "IntervalPriceVector_assign", _wrap_IntervalPriceVector_assign, METH_VARARGS, NULL},
	 { "IntervalPriceVector_resize", _wrap_IntervalPriceVector_resize, METH_VARARGS, NULL},
	 { "IntervalPriceVector_insert", _wrap_IntervalPriceVector_insert, METH_VARARGS, NULL},
	 { "IntervalPriceVector_reserve", _wrap_IntervalPriceVector_reserve, METH_VARARGS, NULL},
	 { "IntervalPriceVector_capacity", _wrap_IntervalPriceVector_capacity, METH_O, NULL},
	 { "delete_IntervalPriceVector", _wrap_delete_IntervalPriceVector, METH_O, NULL},
	 { "IntervalPriceVector_swigregister", IntervalPriceVector_swigregister, METH_O, NULL},
	 { "IntervalPriceVector_swiginit", IntervalPriceVector_swiginit, METH_VARARGS, NULL},
	 { "new_IntervalPrice", _wrap_new_IntervalPrice, METH_VARARGS, NULL},
	 { "IntervalPrice_setValue", _wrap_IntervalPrice_setValue, METH_VARARGS, NULL},
	 { "IntervalPrice_setValues", _wrap_IntervalPrice_setValues, METH_VARARGS, NULL},
	 { "IntervalPrice_value", _wrap_IntervalPrice_value, METH_VARARGS, NULL},
	 { "IntervalPrice_open", _wrap_IntervalPrice_open, METH_O, NULL},
	 { "IntervalPrice_close", _wrap_IntervalPrice_close, METH_O, NULL},
	 { "IntervalPrice_high", _wrap_IntervalPrice_high, METH_O, NULL},
	 { "IntervalPrice_low", _wrap_IntervalPrice_low, METH_O, NULL},
	 { "IntervalPrice_makeSeries", _wrap_IntervalPrice_makeSeries, METH_VARARGS, NULL},
	 { "IntervalPrice_extractValues", _wrap_IntervalPrice_extractValues, METH_VARARGS, NULL},
	 { "IntervalPrice_extractComponent", _wrap_IntervalPrice_extractComponent, METH_VARARGS, NULL},
	 { "delete_IntervalPrice", _wrap_delete_IntervalPrice, METH_O, NULL},
	 { "IntervalPrice_swigregister", IntervalPrice_swigregister, METH_O, NULL},
	 { "IntervalPrice_swiginit", IntervalPrice_swiginit, METH_VARARGS, NULL},
	 { "IndexManager_instance", _wrap_IndexManager_instance, METH_NOARGS, NULL},
	 { "IndexManager_setHistory", _wrap_IndexManager_setHistory, METH_VARARGS, NULL},
	 { "IndexManager_getHistory", _wrap_IndexManager_getHistory, METH_VARARGS, NULL},
	 { "IndexManager_hasHistory", _wrap_IndexManager_hasHistory, METH_VARARGS, NULL},
	 { "IndexManager_histories", _wrap_IndexManager_histories, METH_O, NULL},
	 { "IndexManager_clearHistory", _wrap_IndexManager_clearHistory, METH_VARARGS, NULL},
	 { "IndexManager_clearHistories", _wrap_IndexManager_clearHistories, METH_O, NULL},
	 { "delete_IndexManager", _wrap_delete_IndexManager, METH_O, NULL},
	 { "IndexManager_swigregister", IndexManager_swigregister, METH_O, NULL},
	 { "Index_name", _wrap_Index_name, METH_O, NULL},
	 { "Index_fixingCalendar", _wrap_Index_fixingCalendar, METH_O, NULL},
	 { "Index_isValidFixingDate", _wrap_Index_isValidFixingDate, METH_VARARGS, NULL},
	 { "Index_fixing", _wrap_Index_fixing, METH_VARARGS, NULL},
	 { "Index_addFixing", _wrap_Index_addFixing, METH_VARARGS, NULL},
	 { "Index_timeSeries", _wrap_Index_timeSeries, METH_O, NULL},
	 { "Index_clearFixings", _wrap_Index_clearFixings, METH_O, NULL},
	 { "Index_addFixings", _wrap_Index_addFixings, METH_VARARGS, NULL},
	 { "Index___str__", _wrap_Index___str__, METH_O, NULL},
	 { "delete_Index", _wrap_delete_Index, METH_O, NULL},
	 { "Index_swigregister", Index_swigregister, METH_O, NULL},
	 { "InterestRateIndex_familyName", _wrap_InterestRateIndex_familyName, METH_O, NULL},
	 { "InterestRateIndex_tenor", _wrap_InterestRateIndex_tenor, METH_O, NULL},
	 { "InterestRateIndex_fixingDays", _wrap_InterestRateIndex_fixingDays, METH_O, NULL},
	 { "InterestRateIndex_fixingDate", _wrap_InterestRateIndex_fixingDate, METH_VARARGS, NULL},
	 { "InterestRateIndex_currency", _wrap_InterestRateIndex_currency, METH_O, NULL},
	 { "InterestRateIndex_dayCounter", _wrap_InterestRateIndex_dayCounter, METH_O, NULL},
	 { "InterestRateIndex_maturityDate", _wrap_InterestRateIndex_maturityDate, METH_VARARGS, NULL},
	 { "InterestRateIndex_valueDate", _wrap_InterestRateIndex_valueDate, METH_VARARGS, NULL},
	 { "delete_InterestRateIndex", _wrap_delete_InterestRateIndex, METH_O, NULL},
	 { "InterestRateIndex_swigregister", InterestRateIndex_swigregister, METH_O, NULL},
	 { "new_IborIndex", _wrap_new_IborIndex, METH_VARARGS, NULL},
	 { "IborIndex_businessDayConvention", _wrap_IborIndex_businessDayConvention, METH_O, NULL},
	 { "IborIndex_endOfMonth", _wrap_IborIndex_endOfMonth, METH_O, NULL},
	 { "IborIndex_forwardingTermStructure", _wrap_IborIndex_forwardingTermStructure, METH_O, NULL},
	 { "IborIndex_clone", _wrap_IborIndex_clone, METH_VARARGS, NULL},
	 { "delete_IborIndex", _wrap_delete_IborIndex, METH_O, NULL},
	 { "IborIndex_swigregister", IborIndex_swigregister, METH_O, NULL},
	 { "IborIndex_swiginit", IborIndex_swiginit, METH_VARARGS, NULL},
	 { "as_iborindex", _wrap_as_iborindex, METH_O, NULL},
	 { "new_OvernightIndex", _wrap_new_OvernightIndex, METH_VARARGS, NULL},
	 { "OvernightIndex_clone", _wrap_OvernightIndex_clone, METH_VARARGS, NULL},
	 { "delete_OvernightIndex", _wrap_delete_OvernightIndex, METH_O, NULL},
	 { "OvernightIndex_swigregister", OvernightIndex_swigregister, METH_O, NULL},
	 { "OvernightIndex_swiginit", OvernightIndex_swiginit, METH_VARARGS, NULL},
	 { "new_Libor", _wrap_new_Libor, METH_VARARGS, NULL},
	 { "delete_Libor", _wrap_delete_Libor, METH_O, NULL},
	 { "Libor_swigregister", Libor_swigregister, METH_O, NULL},
	 { "Libor_swiginit", Libor_swiginit, METH_VARARGS, NULL},
	 { "new_DailyTenorLibor", _wrap_new_DailyTenorLibor, METH_VARARGS, NULL},
	 { "delete_DailyTenorLibor", _wrap_delete_DailyTenorLibor, METH_O, NULL},
	 { "DailyTenorLibor_swigregister", DailyTenorLibor_swigregister, METH_O, NULL},
	 { "DailyTenorLibor_swiginit", DailyTenorLibor_swiginit, METH_VARARGS, NULL},
	 { "new_SwapIndex", _wrap_new_SwapIndex, METH_VARARGS, NULL},
	 { "SwapIndex_fixedLegTenor", _wrap_SwapIndex_fixedLegTenor, METH_O, NULL},
	 { "SwapIndex_fixedLegConvention", _wrap_SwapIndex_fixedLegConvention, METH_O, NULL},
	 { "SwapIndex_iborIndex", _wrap_SwapIndex_iborIndex, METH_O, NULL},
	 { "SwapIndex_forwardingTermStructure", _wrap_SwapIndex_forwardingTermStructure, METH_O, NULL},
	 { "SwapIndex_discountingTermStructure", _wrap_SwapIndex_discountingTermStructure, METH_O, NULL},
	 { "SwapIndex_clone", _wrap_SwapIndex_clone, METH_VARARGS, NULL},
	 { "delete_SwapIndex", _wrap_delete_SwapIndex, METH_O, NULL},
	 { "SwapIndex_swigregister", SwapIndex_swigregister, METH_O, NULL},
	 { "SwapIndex_swiginit", SwapIndex_swiginit, METH_VARARGS, NULL},
	 { "SwapIndexVector_iterator", _wrap_SwapIndexVector_iterator, METH_O, NULL},
	 { "SwapIndexVector___nonzero__", _wrap_SwapIndexVector___nonzero__, METH_O, NULL},
	 { "SwapIndexVector___bool__", _wrap_SwapIndexVector___bool__, METH_O, NULL},
	 { "SwapIndexVector___len__", _wrap_SwapIndexVector___len__, METH_O, NULL},
	 { "SwapIndexVector___getslice__", _wrap_SwapIndexVector___getslice__, METH_VARARGS, NULL},
	 { "SwapIndexVector___setslice__", _wrap_SwapIndexVector___setslice__, METH_VARARGS, NULL},
	 { "SwapIndexVector___delslice__", _wrap_SwapIndexVector___delslice__, METH_VARARGS, NULL},
	 { "SwapIndexVector___delitem__", _wrap_SwapIndexVector___delitem__, METH_VARARGS, NULL},
	 { "SwapIndexVector___getitem__", _wrap_SwapIndexVector___getitem__, METH_VARARGS, NULL},
	 { "SwapIndexVector___setitem__", _wrap_SwapIndexVector___setitem__, METH_VARARGS, NULL},
	 { "SwapIndexVector_pop", _wrap_SwapIndexVector_pop, METH_O, NULL},
	 { "SwapIndexVector_append", _wrap_SwapIndexVector_append, METH_VARARGS, NULL},
	 { "SwapIndexVector_empty", _wrap_SwapIndexVector_empty, METH_O, NULL},
	 { "SwapIndexVector_size", _wrap_SwapIndexVector_size, METH_O, NULL},
	 { "SwapIndexVector_swap", _wrap_SwapIndexVector_swap, METH_VARARGS, NULL},
	 { "SwapIndexVector_begin", _wrap_SwapIndexVector_begin, METH_O, NULL},
	 { "SwapIndexVector_end", _wrap_SwapIndexVector_end, METH_O, NULL},
	 { "SwapIndexVector_rbegin", _wrap_SwapIndexVector_rbegin, METH_O, NULL},
	 { "SwapIndexVector_rend", _wrap_SwapIndexVector_rend, METH_O, NULL},
	 { "SwapIndexVector_clear", _wrap_SwapIndexVector_clear, METH_O, NULL},
	 { "SwapIndexVector_get_allocator", _wrap_SwapIndexVector_get_allocator, METH_O, NULL},
	 { "SwapIndexVector_pop_back", _wrap_SwapIndexVector_pop_back, METH_O, NULL},
	 { "SwapIndexVector_erase", _wrap_SwapIndexVector_erase, METH_VARARGS, NULL},
	 { "new_SwapIndexVector", _wrap_new_SwapIndexVector, METH_VARARGS, NULL},
	 { "SwapIndexVector_push_back", _wrap_SwapIndexVector_push_back, METH_VARARGS, NULL},
	 { "SwapIndexVector_front", _wrap_SwapIndexVector_front, METH_O, NULL},
	 { "SwapIndexVector_back", _wrap_SwapIndexVector_back, METH_O, NULL},
	 { "SwapIndexVector_assign", _wrap_SwapIndexVector_assign, METH_VARARGS, NULL},
	 { "SwapIndexVector_resize", _wrap_SwapIndexVector_resize, METH_VARARGS, NULL},
	 { "SwapIndexVector_insert", _wrap_SwapIndexVector_insert, METH_VARARGS, NULL},
	 { "SwapIndexVector_reserve", _wrap_SwapIndexVector_reserve, METH_VARARGS, NULL},
	 { "SwapIndexVector_capacity", _wrap_SwapIndexVector_capacity, METH_O, NULL},
	 { "delete_SwapIndexVector", _wrap_delete_SwapIndexVector, METH_O, NULL},
	 { "SwapIndexVector_swigregister", SwapIndexVector_swigregister, METH_O, NULL},
	 { "SwapIndexVector_swiginit", SwapIndexVector_swiginit, METH_VARARGS, NULL},
	 { "as_swap_index", _wrap_as_swap_index, METH_O, NULL},
	 { "new_SwapSpreadIndex", _wrap_new_SwapSpreadIndex, METH_VARARGS, NULL},
	 { "SwapSpreadIndex_forecastFixing", _wrap_SwapSpreadIndex_forecastFixing, METH_VARARGS, NULL},
	 { "SwapSpreadIndex_pastFixing", _wrap_SwapSpreadIndex_pastFixing, METH_VARARGS, NULL},
	 { "SwapSpreadIndex_swapIndex1", _wrap_SwapSpreadIndex_swapIndex1, METH_O, NULL},
	 { "SwapSpreadIndex_swapIndex2", _wrap_SwapSpreadIndex_swapIndex2, METH_O, NULL},
	 { "SwapSpreadIndex_gearing1", _wrap_SwapSpreadIndex_gearing1, METH_O, NULL},
	 { "SwapSpreadIndex_gearing2", _wrap_SwapSpreadIndex_gearing2, METH_O, NULL},
	 { "delete_SwapSpreadIndex", _wrap_delete_SwapSpreadIndex, METH_O, NULL},
	 { "SwapSpreadIndex_swigregister", SwapSpreadIndex_swigregister, METH_O, NULL},
	 { "SwapSpreadIndex_swiginit", SwapSpreadIndex_swiginit, METH_VARARGS, NULL},
	 { "new_AUDLibor", _wrap_new_AUDLibor, METH_VARARGS, NULL},
	 { "delete_AUDLibor", _wrap_delete_AUDLibor, METH_O, NULL},
	 { "AUDLibor_swigregister", AUDLibor_swigregister, METH_O, NULL},
	 { "AUDLibor_swiginit", AUDLibor_swiginit, METH_VARARGS, NULL},
	 { "new_CADLibor", _wrap_new_CADLibor, METH_VARARGS, NULL},
	 { "delete_CADLibor", _wrap_delete_CADLibor, METH_O, NULL},
	 { "CADLibor_swigregister", CADLibor_swigregister, METH_O, NULL},
	 { "CADLibor_swiginit", CADLibor_swiginit, METH_VARARGS, NULL},
	 { "new_CADLiborON", _wrap_new_CADLiborON, METH_VARARGS, NULL},
	 { "delete_CADLiborON", _wrap_delete_CADLiborON, METH_O, NULL},
	 { "CADLiborON_swigregister", CADLiborON_swigregister, METH_O, NULL},
	 { "CADLiborON_swiginit", CADLiborON_swiginit, METH_VARARGS, NULL},
	 { "new_Cdor", _wrap_new_Cdor, METH_VARARGS, NULL},
	 { "delete_Cdor", _wrap_delete_Cdor, METH_O, NULL},
	 { "Cdor_swigregister", Cdor_swigregister, METH_O, NULL},
	 { "Cdor_swiginit", Cdor_swiginit, METH_VARARGS, NULL},
	 { "new_CHFLibor", _wrap_new_CHFLibor, METH_VARARGS, NULL},
	 { "delete_CHFLibor", _wrap_delete_CHFLibor, METH_O, NULL},
	 { "CHFLibor_swigregister", CHFLibor_swigregister, METH_O, NULL},
	 { "CHFLibor_swiginit", CHFLibor_swiginit, METH_VARARGS, NULL},
	 { "new_DKKLibor", _wrap_new_DKKLibor, METH_VARARGS, NULL},
	 { "delete_DKKLibor", _wrap_delete_DKKLibor, METH_O, NULL},
	 { "DKKLibor_swigregister", DKKLibor_swigregister, METH_O, NULL},
	 { "DKKLibor_swiginit", DKKLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw", _wrap_new_Bbsw, METH_VARARGS, NULL},
	 { "delete_Bbsw", _wrap_delete_Bbsw, METH_O, NULL},
	 { "Bbsw_swigregister", Bbsw_swigregister, METH_O, NULL},
	 { "Bbsw_swiginit", Bbsw_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw1M", _wrap_new_Bbsw1M, METH_VARARGS, NULL},
	 { "delete_Bbsw1M", _wrap_delete_Bbsw1M, METH_O, NULL},
	 { "Bbsw1M_swigregister", Bbsw1M_swigregister, METH_O, NULL},
	 { "Bbsw1M_swiginit", Bbsw1M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw2M", _wrap_new_Bbsw2M, METH_VARARGS, NULL},
	 { "delete_Bbsw2M", _wrap_delete_Bbsw2M, METH_O, NULL},
	 { "Bbsw2M_swigregister", Bbsw2M_swigregister, METH_O, NULL},
	 { "Bbsw2M_swiginit", Bbsw2M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw3M", _wrap_new_Bbsw3M, METH_VARARGS, NULL},
	 { "delete_Bbsw3M", _wrap_delete_Bbsw3M, METH_O, NULL},
	 { "Bbsw3M_swigregister", Bbsw3M_swigregister, METH_O, NULL},
	 { "Bbsw3M_swiginit", Bbsw3M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw4M", _wrap_new_Bbsw4M, METH_VARARGS, NULL},
	 { "delete_Bbsw4M", _wrap_delete_Bbsw4M, METH_O, NULL},
	 { "Bbsw4M_swigregister", Bbsw4M_swigregister, METH_O, NULL},
	 { "Bbsw4M_swiginit", Bbsw4M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw5M", _wrap_new_Bbsw5M, METH_VARARGS, NULL},
	 { "delete_Bbsw5M", _wrap_delete_Bbsw5M, METH_O, NULL},
	 { "Bbsw5M_swigregister", Bbsw5M_swigregister, METH_O, NULL},
	 { "Bbsw5M_swiginit", Bbsw5M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw6M", _wrap_new_Bbsw6M, METH_VARARGS, NULL},
	 { "delete_Bbsw6M", _wrap_delete_Bbsw6M, METH_O, NULL},
	 { "Bbsw6M_swigregister", Bbsw6M_swigregister, METH_O, NULL},
	 { "Bbsw6M_swiginit", Bbsw6M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm", _wrap_new_Bkbm, METH_VARARGS, NULL},
	 { "delete_Bkbm", _wrap_delete_Bkbm, METH_O, NULL},
	 { "Bkbm_swigregister", Bkbm_swigregister, METH_O, NULL},
	 { "Bkbm_swiginit", Bkbm_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm1M", _wrap_new_Bkbm1M, METH_VARARGS, NULL},
	 { "delete_Bkbm1M", _wrap_delete_Bkbm1M, METH_O, NULL},
	 { "Bkbm1M_swigregister", Bkbm1M_swigregister, METH_O, NULL},
	 { "Bkbm1M_swiginit", Bkbm1M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm2M", _wrap_new_Bkbm2M, METH_VARARGS, NULL},
	 { "delete_Bkbm2M", _wrap_delete_Bkbm2M, METH_O, NULL},
	 { "Bkbm2M_swigregister", Bkbm2M_swigregister, METH_O, NULL},
	 { "Bkbm2M_swiginit", Bkbm2M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm3M", _wrap_new_Bkbm3M, METH_VARARGS, NULL},
	 { "delete_Bkbm3M", _wrap_delete_Bkbm3M, METH_O, NULL},
	 { "Bkbm3M_swigregister", Bkbm3M_swigregister, METH_O, NULL},
	 { "Bkbm3M_swiginit", Bkbm3M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm4M", _wrap_new_Bkbm4M, METH_VARARGS, NULL},
	 { "delete_Bkbm4M", _wrap_delete_Bkbm4M, METH_O, NULL},
	 { "Bkbm4M_swigregister", Bkbm4M_swigregister, METH_O, NULL},
	 { "Bkbm4M_swiginit", Bkbm4M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm5M", _wrap_new_Bkbm5M, METH_VARARGS, NULL},
	 { "delete_Bkbm5M", _wrap_delete_Bkbm5M, METH_O, NULL},
	 { "Bkbm5M_swigregister", Bkbm5M_swigregister, METH_O, NULL},
	 { "Bkbm5M_swiginit", Bkbm5M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm6M", _wrap_new_Bkbm6M, METH_VARARGS, NULL},
	 { "delete_Bkbm6M", _wrap_delete_Bkbm6M, METH_O, NULL},
	 { "Bkbm6M_swigregister", Bkbm6M_swigregister, METH_O, NULL},
	 { "Bkbm6M_swiginit", Bkbm6M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor", _wrap_new_Euribor, METH_VARARGS, NULL},
	 { "delete_Euribor", _wrap_delete_Euribor, METH_O, NULL},
	 { "Euribor_swigregister", Euribor_swigregister, METH_O, NULL},
	 { "Euribor_swiginit", Euribor_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSW", _wrap_new_EuriborSW, METH_VARARGS, NULL},
	 { "delete_EuriborSW", _wrap_delete_EuriborSW, METH_O, NULL},
	 { "EuriborSW_swigregister", EuriborSW_swigregister, METH_O, NULL},
	 { "EuriborSW_swiginit", EuriborSW_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor2W", _wrap_new_Euribor2W, METH_VARARGS, NULL},
	 { "delete_Euribor2W", _wrap_delete_Euribor2W, METH_O, NULL},
	 { "Euribor2W_swigregister", Euribor2W_swigregister, METH_O, NULL},
	 { "Euribor2W_swiginit", Euribor2W_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor3W", _wrap_new_Euribor3W, METH_VARARGS, NULL},
	 { "delete_Euribor3W", _wrap_delete_Euribor3W, METH_O, NULL},
	 { "Euribor3W_swigregister", Euribor3W_swigregister, METH_O, NULL},
	 { "Euribor3W_swiginit", Euribor3W_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor1M", _wrap_new_Euribor1M, METH_VARARGS, NULL},
	 { "delete_Euribor1M", _wrap_delete_Euribor1M, METH_O, NULL},
	 { "Euribor1M_swigregister", Euribor1M_swigregister, METH_O, NULL},
	 { "Euribor1M_swiginit", Euribor1M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor2M", _wrap_new_Euribor2M, METH_VARARGS, NULL},
	 { "delete_Euribor2M", _wrap_delete_Euribor2M, METH_O, NULL},
	 { "Euribor2M_swigregister", Euribor2M_swigregister, METH_O, NULL},
	 { "Euribor2M_swiginit", Euribor2M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor3M", _wrap_new_Euribor3M, METH_VARARGS, NULL},
	 { "delete_Euribor3M", _wrap_delete_Euribor3M, METH_O, NULL},
	 { "Euribor3M_swigregister", Euribor3M_swigregister, METH_O, NULL},
	 { "Euribor3M_swiginit", Euribor3M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor4M", _wrap_new_Euribor4M, METH_VARARGS, NULL},
	 { "delete_Euribor4M", _wrap_delete_Euribor4M, METH_O, NULL},
	 { "Euribor4M_swigregister", Euribor4M_swigregister, METH_O, NULL},
	 { "Euribor4M_swiginit", Euribor4M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor5M", _wrap_new_Euribor5M, METH_VARARGS, NULL},
	 { "delete_Euribor5M", _wrap_delete_Euribor5M, METH_O, NULL},
	 { "Euribor5M_swigregister", Euribor5M_swigregister, METH_O, NULL},
	 { "Euribor5M_swiginit", Euribor5M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor6M", _wrap_new_Euribor6M, METH_VARARGS, NULL},
	 { "delete_Euribor6M", _wrap_delete_Euribor6M, METH_O, NULL},
	 { "Euribor6M_swigregister", Euribor6M_swigregister, METH_O, NULL},
	 { "Euribor6M_swiginit", Euribor6M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor7M", _wrap_new_Euribor7M, METH_VARARGS, NULL},
	 { "delete_Euribor7M", _wrap_delete_Euribor7M, METH_O, NULL},
	 { "Euribor7M_swigregister", Euribor7M_swigregister, METH_O, NULL},
	 { "Euribor7M_swiginit", Euribor7M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor8M", _wrap_new_Euribor8M, METH_VARARGS, NULL},
	 { "delete_Euribor8M", _wrap_delete_Euribor8M, METH_O, NULL},
	 { "Euribor8M_swigregister", Euribor8M_swigregister, METH_O, NULL},
	 { "Euribor8M_swiginit", Euribor8M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor9M", _wrap_new_Euribor9M, METH_VARARGS, NULL},
	 { "delete_Euribor9M", _wrap_delete_Euribor9M, METH_O, NULL},
	 { "Euribor9M_swigregister", Euribor9M_swigregister, METH_O, NULL},
	 { "Euribor9M_swiginit", Euribor9M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor10M", _wrap_new_Euribor10M, METH_VARARGS, NULL},
	 { "delete_Euribor10M", _wrap_delete_Euribor10M, METH_O, NULL},
	 { "Euribor10M_swigregister", Euribor10M_swigregister, METH_O, NULL},
	 { "Euribor10M_swiginit", Euribor10M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor11M", _wrap_new_Euribor11M, METH_VARARGS, NULL},
	 { "delete_Euribor11M", _wrap_delete_Euribor11M, METH_O, NULL},
	 { "Euribor11M_swigregister", Euribor11M_swigregister, METH_O, NULL},
	 { "Euribor11M_swiginit", Euribor11M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor1Y", _wrap_new_Euribor1Y, METH_VARARGS, NULL},
	 { "delete_Euribor1Y", _wrap_delete_Euribor1Y, METH_O, NULL},
	 { "Euribor1Y_swigregister", Euribor1Y_swigregister, METH_O, NULL},
	 { "Euribor1Y_swiginit", Euribor1Y_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365", _wrap_new_Euribor365, METH_VARARGS, NULL},
	 { "delete_Euribor365", _wrap_delete_Euribor365, METH_O, NULL},
	 { "Euribor365_swigregister", Euribor365_swigregister, METH_O, NULL},
	 { "Euribor365_swiginit", Euribor365_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_SW", _wrap_new_Euribor365_SW, METH_VARARGS, NULL},
	 { "delete_Euribor365_SW", _wrap_delete_Euribor365_SW, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_2W", _wrap_delete_Euribor365_2W, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_3W", _wrap_delete_Euribor365_3W, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_1M", _wrap_delete_Euribor365_1M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_2M", _wrap_delete_Euribor365_2M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_3M", _wrap_delete_Euribor365_3M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_4M", _wrap_delete_Euribor365_4M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_5M", _wrap_delete_Euribor365_5M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_6M", _wrap_delete_Euribor365_6M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_7M", _wrap_delete_Euribor365_7M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_8M", _wrap_delete_Euribor365_8M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_9M", _wrap_delete_Euribor365_9M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_10M", _wrap_delete_Euribor365_10M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_11M", _wrap_delete_Euribor365_11M, METH_O, NULL},
	 { "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, NULL},
	 { "delete_Euribor365_1Y", _wrap_delete_Euribor365_1Y, METH_O, NULL},
	 { "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, NULL},
	 { "delete_EURLibor", _wrap_delete_EURLibor, METH_O, NULL},
	 { "EURLibor_swigregister", EURLibor_swigregister, METH_O, NULL},
	 { "EURLibor_swiginit", EURLibor_swiginit, METH_VARARGS, NULL},
	 { "new_EURLiborSW", _wrap_new_EURLiborSW, METH_VARARGS, NULL},
	 { "delete_EURLiborSW", _wrap_delete_EURLiborSW, METH_O, NULL},
	 { "EURLiborSW_swigregister", EURLiborSW_swigregister, METH_O, NULL},
	 { "EURLiborSW_swiginit", EURLiborSW_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor2W", _wrap_new_EURLibor2W, METH_VARARGS, NULL},
	 { "delete_EURLibor2W", _wrap_delete_EURLibor2W, METH_O, NULL},
	 { "EURLibor2W_swigregister", EURLibor2W_swigregister, METH_O, NULL},
	 { "EURLibor2W_swiginit", EURLibor2W_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor1M", _wrap_new_EURLibor1M, METH_VARARGS, NULL},
	 { "delete_EURLibor1M", _wrap_delete_EURLibor1M, METH_O, NULL},
	 { "EURLibor1M_swigregister", EURLibor1M_swigregister, METH_O, NULL},
	 { "EURLibor1M_swiginit", EURLibor1M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor2M", _wrap_new_EURLibor2M, METH_VARARGS, NULL},
	 { "delete_EURLibor2M", _wrap_delete_EURLibor2M, METH_O, NULL},
	 { "EURLibor2M_swigregister", EURLibor2M_swigregister, METH_O, NULL},
	 { "EURLibor2M_swiginit", EURLibor2M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor3M", _wrap_new_EURLibor3M, METH_VARARGS, NULL},
	 { "delete_EURLibor3M", _wrap_delete_EURLibor3M, METH_O, NULL},
	 { "EURLibor3M_swigregister", EURLibor3M_swigregister, METH_O, NULL},
	 { "EURLibor3M_swiginit", EURLibor3M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor4M", _wrap_new_EURLibor4M, METH_VARARGS, NULL},
	 { "delete_EURLibor4M", _wrap_delete_EURLibor4M, METH_O, NULL},
	 { "EURLibor4M_swigregister", EURLibor4M_swigregister, METH_O, NULL},
	 { "EURLibor4M_swiginit", EURLibor4M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor5M", _wrap_new_EURLibor5M, METH_VARARGS, NULL},
	 { "delete_EURLibor5M", _wrap_delete_EURLibor5M, METH_O, NULL},
	 { "EURLibor5M_swigregister", EURLibor5M_swigregister, METH_O, NULL},
	 { "EURLibor5M_swiginit", EURLibor5M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor6M", _wrap_new_EURLibor6M, METH_VARARGS, NULL},
	 { "delete_EURLibor6M", _wrap_delete_EURLibor6M, METH_O, NULL},
	 { "EURLibor6M_swigregister", EURLibor6M_swigregister, METH_O, NULL},
	 { "EURLibor6M_swiginit", EURLibor6M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor7M", _wrap_new_EURLibor7M, METH_VARARGS, NULL},
	 { "delete_EURLibor7M", _wrap_delete_EURLibor7M, METH_O, NULL},
	 { "EURLibor7M_swigregister", EURLibor7M_swigregister, METH_O, NULL},
	 { "EURLibor7M_swiginit", EURLibor7M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor8M", _wrap_new_EURLibor8M, METH_VARARGS, NULL},
	 { "delete_EURLibor8M", _wrap_delete_EURLibor8M, METH_O, NULL},
	 { "EURLibor8M_swigregister", EURLibor8M_swigregister, METH_O, NULL},
	 { "EURLibor8M_swiginit", EURLibor8M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor9M", _wrap_new_EURLibor9M, METH_VARARGS, NULL},
	 { "delete_EURLibor9M", _wrap_delete_EURLibor9M, METH_O, NULL},
	 { "EURLibor9M_swigregister", EURLibor9M_swigregister, METH_O, NULL},
	 { "EURLibor9M_swiginit", EURLibor9M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor10M", _wrap_new_EURLibor10M, METH_VARARGS, NULL},
	 { "delete_EURLibor10M", _wrap_delete_EURLibor10M, METH_O, NULL},
	 { "EURLibor10M_swigregister", EURLibor10M_swigregister, METH_O, NULL},
	 { "EURLibor10M_swiginit", EURLibor10M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor11M", _wrap_new_EURLibor11M, METH_VARARGS, NULL},
	 { "delete_EURLibor11M", _wrap_delete_EURLibor11M, METH_O, NULL},
	 { "EURLibor11M_swigregister", EURLibor11M_swigregister, METH_O, NULL},
	 { "EURLibor11M_swiginit", EURLibor11M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor1Y", _wrap_new_EURLibor1Y, METH_VARARGS, NULL},
	 { "delete_EURLibor1Y", _wrap_delete_EURLibor1Y, METH_O, NULL},
	 { "EURLibor1Y_swigregister", EURLibor1Y_swigregister, METH_O, NULL},
	 { "EURLibor1Y_swiginit", EURLibor1Y_swiginit, METH_VARARGS, NULL},
	 { "new_GBPLibor", _wrap_new_GBPLibor, METH_VARARGS, NULL},
	 { "delete_GBPLibor", _wrap_delete_GBPLibor, METH_O, NULL},
	 { "GBPLibor_swigregister", GBPLibor_swigregister, METH_O, NULL},
	 { "GBPLibor_swiginit", GBPLibor_swiginit, METH_VARARGS, NULL},
	 { "new_GBPLiborON", _wrap_new_GBPLiborON, METH_VARARGS, NULL},
	 { "delete_GBPLiborON", _wrap_delete_GBPLiborON, METH_O, NULL},
	 { "GBPLiborON_swigregister", GBPLiborON_swigregister, METH_O, NULL},
	 { "GBPLiborON_swiginit", GBPLiborON_swiginit, METH_VARARGS, NULL},
	 { "new_Jibar", _wrap_new_Jibar, METH_VARARGS, NULL},
	 { "delete_Jibar", _wrap_delete_Jibar, METH_O, NULL},
	 { "Jibar_swigregister", Jibar_swigregister, METH_O, NULL},
	 { "Jibar_swiginit", Jibar_swiginit, METH_VARARGS, NULL},
	 { "new_JPYLibor", _wrap_new_JPYLibor, METH_VARARGS, NULL},
	 { "delete_JPYLibor", _wrap_delete_JPYLibor, METH_O, NULL},
	 { "JPYLibor_swigregister", JPYLibor_swigregister, METH_O, NULL},
	 { "JPYLibor_swiginit", JPYLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Mosprime", _wrap_new_Mosprime, METH_VARARGS, NULL},
	 { "delete_Mosprime", _wrap_delete_Mosprime, METH_O, NULL},
	 { "Mosprime_swigregister", Mosprime_swigregister, METH_O, NULL},
	 { "Mosprime_swiginit", Mosprime_swiginit, METH_VARARGS, NULL},
	 { "new_NZDLibor", _wrap_new_NZDLibor, METH_VARARGS, NULL},
	 { "delete_NZDLibor", _wrap_delete_NZDLibor, METH_O, NULL},
	 { "NZDLibor_swigregister", NZDLibor_swigregister, METH_O, NULL},
	 { "NZDLibor_swiginit", NZDLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Pribor", _wrap_new_Pribor, METH_VARARGS, NULL},
	 { "delete_Pribor", _wrap_delete_Pribor, METH_O, NULL},
	 { "Pribor_swigregister", Pribor_swigregister, METH_O, NULL},
	 { "Pribor_swiginit", Pribor_swiginit, METH_VARARGS, NULL},
	 { "new_Robor", _wrap_new_Robor, METH_VARARGS, NULL},
	 { "delete_Robor", _wrap_delete_Robor, METH_O, NULL},
	 { "Robor_swigregister", Robor_swigregister, METH_O, NULL},
	 { "Robor_swiginit", Robor_swiginit, METH_VARARGS, NULL},
	 { "new_SEKLibor", _wrap_new_SEKLibor, METH_VARARGS, NULL},
	 { "delete_SEKLibor", _wrap_delete_SEKLibor, METH_O, NULL},
	 { "SEKLibor_swigregister", SEKLibor_swigregister, METH_O, NULL},
	 { "SEKLibor_swiginit", SEKLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Shibor", _wrap_new_Shibor, METH_VARARGS, NULL},
	 { "delete_Shibor", _wrap_delete_Shibor, METH_O, NULL},
	 { "Shibor_swigregister", Shibor_swigregister, METH_O, NULL},
	 { "Shibor_swiginit", Shibor_swiginit, METH_VARARGS, NULL},
	 { "new_Tibor", _wrap_new_Tibor, METH_VARARGS, NULL},
	 { "delete_Tibor", _wrap_delete_Tibor, METH_O, NULL},
	 { "Tibor_swigregister", Tibor_swigregister, METH_O, NULL},
	 { "Tibor_swiginit", Tibor_swiginit, METH_VARARGS, NULL},
	 { "new_THBFIX", _wrap_new_THBFIX, METH_VARARGS, NULL},
	 { "delete_THBFIX", _wrap_delete_THBFIX, METH_O, NULL},
	 { "THBFIX_swigregister", THBFIX_swigregister, METH_O, NULL},
	 { "THBFIX_swiginit", THBFIX_swiginit, METH_VARARGS, NULL},
	 { "new_TRLibor", _wrap_new_TRLibor, METH_VARARGS, NULL},
	 { "delete_TRLibor", _wrap_delete_TRLibor, METH_O, NULL},
	 { "TRLibor_swigregister", TRLibor_swigregister, METH_O, NULL},
	 { "TRLibor_swiginit", TRLibor_swiginit, METH_VARARGS, NULL},
	 { "new_USDLibor", _wrap_new_USDLibor, METH_VARARGS, NULL},
	 { "delete_USDLibor", _wrap_delete_USDLibor, METH_O, NULL},
	 { "USDLibor_swigregister", USDLibor_swigregister, METH_O, NULL},
	 { "USDLibor_swiginit", USDLibor_swiginit, METH_VARARGS, NULL},
	 { "new_USDLiborON", _wrap_new_USDLiborON, METH_VARARGS, NULL},
	 { "delete_USDLiborON", _wrap_delete_USDLiborON, METH_O, NULL},
	 { "USDLiborON_swigregister", USDLiborON_swigregister, METH_O, NULL},
	 { "USDLiborON_swiginit", USDLiborON_swiginit, METH_VARARGS, NULL},
	 { "new_Wibor", _wrap_new_Wibor, METH_VARARGS, NULL},
	 { "delete_Wibor", _wrap_delete_Wibor, METH_O, NULL},
	 { "Wibor_swigregister", Wibor_swigregister, METH_O, NULL},
	 { "Wibor_swiginit", Wibor_swiginit, METH_VARARGS, NULL},
	 { "new_Zibor", _wrap_new_Zibor, METH_VARARGS, NULL},
	 { "delete_Zibor", _wrap_delete_Zibor, METH_O, NULL},
	 { "Zibor_swigregister", Zibor_swigregister, METH_O, NULL},
	 { "Zibor_swiginit", Zibor_swiginit, METH_VARARGS, NULL},
	 { "new_Aonia", _wrap_new_Aonia, METH_VARARGS, NULL},
	 { "delete_Aonia", _wrap_delete_Aonia, METH_O, NULL},
	 { "Aonia_swigregister", Aonia_swigregister, METH_O, NULL},
	 { "Aonia_swiginit", Aonia_swiginit, METH_VARARGS, NULL},
	 { "new_Eonia", _wrap_new_Eonia, METH_VARARGS, NULL},
	 { "delete_Eonia", _wrap_delete_Eonia, METH_O, NULL},
	 { "Eonia_swigregister", Eonia_swigregister, METH_O, NULL},
	 { "Eonia_swiginit", Eonia_swiginit, METH_VARARGS, NULL},
	 { "new_Sonia", _wrap_new_Sonia, METH_VARARGS, NULL},
	 { "delete_Sonia", _wrap_delete_Sonia, METH_O, NULL},
	 { "Sonia_swigregister", Sonia_swigregister, METH_O, NULL},
	 { "Sonia_swiginit", Sonia_swiginit, METH_VARARGS, NULL},
	 { "new_FedFunds", _wrap_new_FedFunds, METH_VARARGS, NULL},
	 { "delete_FedFunds", _wrap_delete_FedFunds, METH_O, NULL},
	 { "FedFunds_swigregister", FedFunds_swigregister, METH_O, NULL},
	 { "FedFunds_swiginit", FedFunds_swiginit, METH_VARARGS, NULL},
	 { "new_Nzocr", _wrap_new_Nzocr, METH_VARARGS, NULL},
	 { "delete_Nzocr", _wrap_delete_Nzocr, METH_O, NULL},
	 { "Nzocr_swigregister", Nzocr_swigregister, METH_O, NULL},
	 { "Nzocr_swiginit", Nzocr_swiginit, METH_VARARGS, NULL},
	 { "new_Sofr", _wrap_new_Sofr, METH_VARARGS, NULL},
	 { "delete_Sofr", _wrap_delete_Sofr, METH_O, NULL},
	 { "Sofr_swigregister", Sofr_swigregister, METH_O, NULL},
	 { "Sofr_swiginit", Sofr_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSwapIsdaFixA", _wrap_new_EuriborSwapIsdaFixA, METH_VARARGS, NULL},
	 { "delete_EuriborSwapIsdaFixA", _wrap_delete_EuriborSwapIsdaFixA, METH_O, NULL},
	 { "EuriborSwapIsdaFixA_swigregister", EuriborSwapIsdaFixA_swigregister, METH_O, NULL},
	 { "EuriborSwapIsdaFixA_swiginit", EuriborSwapIsdaFixA_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSwapIsdaFixB", _wrap_new_EuriborSwapIsdaFixB, METH_VARARGS, NULL},
	 { "delete_EuriborSwapIsdaFixB", _wrap_delete_EuriborSwapIsdaFixB, METH_O, NULL},
	 { "EuriborSwapIsdaFixB_swigregister", EuriborSwapIsdaFixB_swigregister, METH_O, NULL},
	 { "EuriborSwapIsdaFixB_swiginit", EuriborSwapIsdaFixB_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSwapIfrFix", _wrap_new_EuriborSwapIfrFix, METH_VARARGS, NULL},
	 { "delete_EuriborSwapIfrFix", _wrap_delete_EuriborSwapIfrFix, METH_O, NULL},
	 { "EuriborSwapIfrFix_swigregister", EuriborSwapIfrFix_swigregister, METH_O, NULL},
	 { "EuriborSwapIfrFix_swiginit", EuriborSwapIfrFix_swiginit, METH_VARARGS, NULL},
	 { "new_EurLiborSwapIsdaFixA", _wrap_new_EurLiborSwapIsdaFixA, METH_VARARGS, NULL},
	 { "delete_EurLiborSwapIsdaFixA", _wrap_delete_EurLiborSwapIsdaFixA, METH_O, NULL},
	 { "EurLiborSwapIsdaFixA_swigregister", EurLiborSwapIsdaFixA_swigregister, METH_O, NULL},
	 { "EurLiborSwapIsdaFixA_swiginit", EurLiborSwapIsdaFixA_swiginit, METH_VARARGS, NULL},
	 { "new_EurLiborSwapIsdaFixB", _wrap_new_EurLiborSwapIsdaFixB, METH_VARARGS, NULL},
	 { "delete_EurLiborSwapIsdaFixB", _wrap_delete_EurLiborSwapIsdaFixB, METH_O, NULL},
	 { "EurLiborSwapIsdaFixB_swigregister", EurLiborSwapIsdaFixB_swigregister, METH_O, NULL},
	 { "EurLiborSwapIsdaFixB_swiginit", EurLiborSwapIsdaFixB_swiginit, METH_VARARGS, NULL},
	 { "new_EurLiborSwapIfrFix", _wrap_new_EurLiborSwapIfrFix, METH_VARARGS, NULL},
	 { "delete_EurLiborSwapIfrFix", _wrap_delete_EurLiborSwapIfrFix, METH_O, NULL},
	 { "EurLiborSwapIfrFix_swigregister", EurLiborSwapIfrFix_swigregister, METH_O, NULL},
	 { "EurLiborSwapIfrFix_swiginit", EurLiborSwapIfrFix_swiginit, METH_VARARGS, NULL},
	 { "new_ChfLiborSwapIsdaFix", _wrap_new_ChfLiborSwapIsdaFix, METH_VARARGS, NULL},
	 { "delete_ChfLiborSwapIsdaFix", _wrap_delete_ChfLiborSwapIsdaFix, METH_O, NULL},
	 { "ChfLiborSwapIsdaFix_swigregister", ChfLiborSwapIsdaFix_swigregister, METH_O, NULL},
	 { "ChfLiborSwapIsdaFix_swiginit", ChfLiborSwapIsdaFix_swiginit, METH_VARARGS, NULL},
	 { "new_GbpLiborSwapIsdaFix", _wrap_new_GbpLiborSwapIsdaFix, METH_VARARGS, NULL},
	 { "delete_GbpLiborSwapIsdaFix", _wrap_delete_GbpLiborSwapIsdaFix, METH_O, NULL},
	 { "GbpLiborSwapIsdaFix_swigregister", GbpLiborSwapIsdaFix_swigregister, METH_O, NULL},
	 { "GbpLiborSwapIsdaFix_swiginit", GbpLiborSwapIsdaFix_swiginit, METH_VARARGS, NULL},
	 { "new_JpyLiborSwapIsdaFixAm", _wrap_new_JpyLiborSwapIsdaFixAm, METH_VARARGS, NULL},
	 { "delete_JpyLiborSwapIsdaFixAm", _wrap_delete_JpyLiborSwapIsdaFixAm, METH_O, NULL},
	 { "JpyLiborSwapIsdaFixAm_swigregister", JpyLiborSwapIsdaFixAm_swigregister, METH_O, NULL},
	 { "JpyLiborSwapIsdaFixAm_swiginit", JpyLiborSwapIsdaFixAm_swiginit, METH_VARARGS, NULL},
	 { "new_JpyLiborSwapIsdaFixPm", _wrap_new_JpyLiborSwapIsdaFixPm, METH_VARARGS, NULL},
	 { "delete_JpyLiborSwapIsdaFixPm", _wrap_delete_JpyLiborSwapIsdaFixPm, METH_O, NULL},
	 { "JpyLiborSwapIsdaFixPm_swigregister", JpyLiborSwapIsdaFixPm_swigregister, METH_O, NULL},
	 { "JpyLiborSwapIsdaFixPm_swiginit", JpyLiborSwapIsdaFixPm_swiginit, METH_VARARGS, NULL},
	 { "new_UsdLiborSwapIsdaFixAm", _wrap_new_UsdLiborSwapIsdaFixAm, METH_VARARGS, NULL},
	 { "delete_UsdLiborSwapIsdaFixAm", _wrap_delete_UsdLiborSwapIsdaFixAm, METH_O, NULL},
	 { "UsdLiborSwapIsdaFixAm_swigregister", UsdLiborSwapIsdaFixAm_swigregister, METH_O, NULL},
	 { "UsdLiborSwapIsdaFixAm_swiginit", UsdLiborSwapIsdaFixAm_swiginit, METH_VARARGS, NULL},
	 { "new_UsdLiborSwapIsdaFixPm", _wrap_new_UsdLiborSwapIsdaFixPm, METH_VARARGS, NULL},
	 { "delete_UsdLiborSwapIsdaFixPm", _wrap_delete_UsdLiborSwapIsdaFixPm, METH_O, NULL},
	 { "UsdLiborSwapIsdaFixPm_swigregister", UsdLiborSwapIsdaFixPm_swigregister, METH_O, NULL},
	 { "UsdLiborSwapIsdaFixPm_swiginit", UsdLiborSwapIsdaFixPm_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor", _wrap_new_Bibor, METH_VARARGS, NULL},
	 { "delete_Bibor", _wrap_delete_Bibor, METH_O, NULL},
	 { "Bibor_swigregister", Bibor_swigregister, METH_O, NULL},
	 { "Bibor_swiginit", Bibor_swiginit, METH_VARARGS, NULL},
	 { "new_BiborSW", _wrap_new_BiborSW, METH_VARARGS, NULL},
	 { "delete_BiborSW", _wrap_delete_BiborSW, METH_O, NULL},
	 { "BiborSW_swigregister", BiborSW_swigregister, METH_O, NULL},
	 { "BiborSW_swiginit", BiborSW_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor1M", _wrap_new_Bibor1M, METH_VARARGS, NULL},
	 { "delete_Bibor1M", _wrap_delete_Bibor1M, METH_O, NULL},
	 { "Bibor1M_swigregister", Bibor1M_swigregister, METH_O, NULL},
	 { "Bibor1M_swiginit", Bibor1M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor2M", _wrap_new_Bibor2M, METH_VARARGS, NULL},
	 { "delete_Bibor2M", _wrap_delete_Bibor2M, METH_O, NULL},
	 { "Bibor2M_swigregister", Bibor2M_swigregister, METH_O, NULL},
	 { "Bibor2M_swiginit", Bibor2M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor3M", _wrap_new_Bibor3M, METH_VARARGS, NULL},
	 { "delete_Bibor3M", _wrap_delete_Bibor3M, METH_O, NULL},
	 { "Bibor3M_swigregister", Bibor3M_swigregister, METH_O, NULL},
	 { "Bibor3M_swiginit", Bibor3M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor6M", _wrap_new_Bibor6M, METH_VARARGS, NULL},
	 { "delete_Bibor6M", _wrap_delete_Bibor6M, METH_O, NULL},
	 { "Bibor6M_swigregister", Bibor6M_swigregister, METH_O, NULL},
	 { "Bibor6M_swiginit", Bibor6M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor9M", _wrap_new_Bibor9M, METH_VARARGS, NULL},
	 { "delete_Bibor9M", _wrap_delete_Bibor9M, METH_O, NULL},
	 { "Bibor9M_swigregister", Bibor9M_swigregister, METH_O, NULL},
	 { "Bibor9M_swiginit", Bibor9M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor1Y", _wrap_new_Bibor1Y, METH_VARARGS, NULL},
	 { "delete_Bibor1Y", _wrap_delete_Bibor1Y, METH_O, NULL},
	 { "Bibor1Y_swigregister", Bibor1Y_swigregister, METH_O, NULL},
	 { "Bibor1Y_swiginit", Bibor1Y_swiginit, METH_VARARGS, NULL},
	 { "VolatilityTermStructure_minStrike", _wrap_VolatilityTermStructure_minStrike, METH_O, NULL},
	 { "VolatilityTermStructure_maxStrike", _wrap_VolatilityTermStructure_maxStrike, METH_O, NULL},
	 { "delete_VolatilityTermStructure", _wrap_delete_VolatilityTermStructure, METH_O, NULL},
	 { "VolatilityTermStructure_swigregister", VolatilityTermStructure_swigregister, METH_O, NULL},
	 { "BlackVolTermStructure_blackVol", _wrap_BlackVolTermStructure_blackVol, METH_VARARGS, NULL},
	 { "BlackVolTermStructure_blackVariance", _wrap_BlackVolTermStructure_blackVariance, METH_VARARGS, NULL},
	 { "BlackVolTermStructure_blackForwardVol", _wrap_BlackVolTermStructure_blackForwardVol, METH_VARARGS, NULL},
	 { "BlackVolTermStructure_blackForwardVariance", _wrap_BlackVolTermStructure_blackForwardVariance, METH_VARARGS, NULL},
	 { "delete_BlackVolTermStructure", _wrap_delete_BlackVolTermStructure, METH_O, NULL},
	 { "BlackVolTermStructure_swigregister", BlackVolTermStructure_swigregister, METH_O, NULL},
	 { "new_BlackVolTermStructureHandle", _wrap_new_BlackVolTermStructureHandle, METH_VARARGS, NULL},
	 { "BlackVolTermStructureHandle___deref__", _wrap_BlackVolTermStructureHandle___deref__, METH_O, NULL},
	 { "BlackVolTermStructureHandle_currentLink", _wrap_BlackVolTermStructureHandle_currentLink, METH_O, NULL},
	 { "BlackVolTermStructureHandle___nonzero__", _wrap_BlackVolTermStructureHandle___nonzero__, METH_O, NULL},
	 { "BlackVolTermStructureHandle___bool__", _wrap_BlackVolTermStructureHandle___bool__, METH_O, NULL},
	 { "BlackVolTermStructureHandle_asObservable", _wrap_BlackVolTermStructureHandle_asObservable, METH_O, NULL},
	 { "delete_BlackVolTermStructureHandle", _wrap_delete_BlackVolTermStructureHandle, METH_O, NULL},
	 { "BlackVolTermStructureHandle_blackVol", _wrap_BlackVolTermStructureHandle_blackVol, METH_VARARGS, NULL},
	 { "BlackVolTermStructureHandle_blackVariance", _wrap_BlackVolTermStructureHandle_blackVariance, METH_VARARGS, NULL},
	 { "BlackVolTermStructureHandle_blackForwardVol", _wrap_BlackVolTermStructureHandle_blackForwardVol, METH_VARARGS, NULL},
	 { "BlackVolTermStructureHandle_blackForwardVariance", _wrap_BlackVolTermStructureHandle_blackForwardVariance, METH_VARARGS, NULL},
	 { "BlackVolTermStructureHandle_minStrike", _wrap_BlackVolTermStructureHandle_minStrike, METH_O, NULL},
	 { "BlackVolTermStructureHandle_maxStrike", _wrap_BlackVolTermStructureHandle_maxStrike, METH_O, NULL},
	 { "BlackVolTermStructureHandle_dayCounter", _wrap_BlackVolTermStructureHandle_dayCounter, METH_O, NULL},
	 { "BlackVolTermStructureHandle_timeFromReference", _wrap_BlackVolTermStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "BlackVolTermStructureHandle_calendar", _wrap_BlackVolTermStructureHandle_calendar, METH_O, NULL},
	 { "BlackVolTermStructureHandle_referenceDate", _wrap_BlackVolTermStructureHandle_referenceDate, METH_O, NULL},
	 { "BlackVolTermStructureHandle_maxDate", _wrap_BlackVolTermStructureHandle_maxDate, METH_O, NULL},
	 { "BlackVolTermStructureHandle_maxTime", _wrap_BlackVolTermStructureHandle_maxTime, METH_O, NULL},
	 { "BlackVolTermStructureHandle_enableExtrapolation", _wrap_BlackVolTermStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "BlackVolTermStructureHandle_disableExtrapolation", _wrap_BlackVolTermStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "BlackVolTermStructureHandle_allowsExtrapolation", _wrap_BlackVolTermStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "BlackVolTermStructureHandle_swigregister", BlackVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "BlackVolTermStructureHandle_swiginit", BlackVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableBlackVolTermStructureHandle", _wrap_new_RelinkableBlackVolTermStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableBlackVolTermStructureHandle_linkTo", _wrap_RelinkableBlackVolTermStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableBlackVolTermStructureHandle_reset", _wrap_RelinkableBlackVolTermStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableBlackVolTermStructureHandle", _wrap_delete_RelinkableBlackVolTermStructureHandle, METH_O, NULL},
	 { "RelinkableBlackVolTermStructureHandle_swigregister", RelinkableBlackVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableBlackVolTermStructureHandle_swiginit", RelinkableBlackVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "LocalVolTermStructure_localVol", _wrap_LocalVolTermStructure_localVol, METH_VARARGS, NULL},
	 { "delete_LocalVolTermStructure", _wrap_delete_LocalVolTermStructure, METH_O, NULL},
	 { "LocalVolTermStructure_swigregister", LocalVolTermStructure_swigregister, METH_O, NULL},
	 { "new_LocalVolTermStructureHandle", _wrap_new_LocalVolTermStructureHandle, METH_VARARGS, NULL},
	 { "LocalVolTermStructureHandle___deref__", _wrap_LocalVolTermStructureHandle___deref__, METH_O, NULL},
	 { "LocalVolTermStructureHandle_currentLink", _wrap_LocalVolTermStructureHandle_currentLink, METH_O, NULL},
	 { "LocalVolTermStructureHandle___nonzero__", _wrap_LocalVolTermStructureHandle___nonzero__, METH_O, NULL},
	 { "LocalVolTermStructureHandle___bool__", _wrap_LocalVolTermStructureHandle___bool__, METH_O, NULL},
	 { "LocalVolTermStructureHandle_asObservable", _wrap_LocalVolTermStructureHandle_asObservable, METH_O, NULL},
	 { "delete_LocalVolTermStructureHandle", _wrap_delete_LocalVolTermStructureHandle, METH_O, NULL},
	 { "LocalVolTermStructureHandle_localVol", _wrap_LocalVolTermStructureHandle_localVol, METH_VARARGS, NULL},
	 { "LocalVolTermStructureHandle_minStrike", _wrap_LocalVolTermStructureHandle_minStrike, METH_O, NULL},
	 { "LocalVolTermStructureHandle_maxStrike", _wrap_LocalVolTermStructureHandle_maxStrike, METH_O, NULL},
	 { "LocalVolTermStructureHandle_dayCounter", _wrap_LocalVolTermStructureHandle_dayCounter, METH_O, NULL},
	 { "LocalVolTermStructureHandle_timeFromReference", _wrap_LocalVolTermStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "LocalVolTermStructureHandle_calendar", _wrap_LocalVolTermStructureHandle_calendar, METH_O, NULL},
	 { "LocalVolTermStructureHandle_referenceDate", _wrap_LocalVolTermStructureHandle_referenceDate, METH_O, NULL},
	 { "LocalVolTermStructureHandle_maxDate", _wrap_LocalVolTermStructureHandle_maxDate, METH_O, NULL},
	 { "LocalVolTermStructureHandle_maxTime", _wrap_LocalVolTermStructureHandle_maxTime, METH_O, NULL},
	 { "LocalVolTermStructureHandle_enableExtrapolation", _wrap_LocalVolTermStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "LocalVolTermStructureHandle_disableExtrapolation", _wrap_LocalVolTermStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "LocalVolTermStructureHandle_allowsExtrapolation", _wrap_LocalVolTermStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "LocalVolTermStructureHandle_swigregister", LocalVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "LocalVolTermStructureHandle_swiginit", LocalVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableLocalVolTermStructureHandle", _wrap_new_RelinkableLocalVolTermStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableLocalVolTermStructureHandle_linkTo", _wrap_RelinkableLocalVolTermStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableLocalVolTermStructureHandle_reset", _wrap_RelinkableLocalVolTermStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableLocalVolTermStructureHandle", _wrap_delete_RelinkableLocalVolTermStructureHandle, METH_O, NULL},
	 { "RelinkableLocalVolTermStructureHandle_swigregister", RelinkableLocalVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableLocalVolTermStructureHandle_swiginit", RelinkableLocalVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructure_volatility", _wrap_OptionletVolatilityStructure_volatility, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructure_blackVariance", _wrap_OptionletVolatilityStructure_blackVariance, METH_VARARGS, NULL},
	 { "delete_OptionletVolatilityStructure", _wrap_delete_OptionletVolatilityStructure, METH_O, NULL},
	 { "OptionletVolatilityStructure_swigregister", OptionletVolatilityStructure_swigregister, METH_O, NULL},
	 { "new_OptionletVolatilityStructureHandle", _wrap_new_OptionletVolatilityStructureHandle, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructureHandle___deref__", _wrap_OptionletVolatilityStructureHandle___deref__, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_currentLink", _wrap_OptionletVolatilityStructureHandle_currentLink, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle___nonzero__", _wrap_OptionletVolatilityStructureHandle___nonzero__, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle___bool__", _wrap_OptionletVolatilityStructureHandle___bool__, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_asObservable", _wrap_OptionletVolatilityStructureHandle_asObservable, METH_O, NULL},
	 { "delete_OptionletVolatilityStructureHandle", _wrap_delete_OptionletVolatilityStructureHandle, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_volatility", _wrap_OptionletVolatilityStructureHandle_volatility, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructureHandle_blackVariance", _wrap_OptionletVolatilityStructureHandle_blackVariance, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructureHandle_minStrike", _wrap_OptionletVolatilityStructureHandle_minStrike, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_maxStrike", _wrap_OptionletVolatilityStructureHandle_maxStrike, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_dayCounter", _wrap_OptionletVolatilityStructureHandle_dayCounter, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_timeFromReference", _wrap_OptionletVolatilityStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructureHandle_calendar", _wrap_OptionletVolatilityStructureHandle_calendar, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_referenceDate", _wrap_OptionletVolatilityStructureHandle_referenceDate, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_maxDate", _wrap_OptionletVolatilityStructureHandle_maxDate, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_maxTime", _wrap_OptionletVolatilityStructureHandle_maxTime, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_enableExtrapolation", _wrap_OptionletVolatilityStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_disableExtrapolation", _wrap_OptionletVolatilityStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_allowsExtrapolation", _wrap_OptionletVolatilityStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_swigregister", OptionletVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_swiginit", OptionletVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableOptionletVolatilityStructureHandle", _wrap_new_RelinkableOptionletVolatilityStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableOptionletVolatilityStructureHandle_linkTo", _wrap_RelinkableOptionletVolatilityStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableOptionletVolatilityStructureHandle_reset", _wrap_RelinkableOptionletVolatilityStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableOptionletVolatilityStructureHandle", _wrap_delete_RelinkableOptionletVolatilityStructureHandle, METH_O, NULL},
	 { "RelinkableOptionletVolatilityStructureHandle_swigregister", RelinkableOptionletVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableOptionletVolatilityStructureHandle_swiginit", RelinkableOptionletVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurface_observationLag", _wrap_YoYOptionletVolatilitySurface_observationLag, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_frequency", _wrap_YoYOptionletVolatilitySurface_frequency, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_indexIsInterpolated", _wrap_YoYOptionletVolatilitySurface_indexIsInterpolated, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_baseDate", _wrap_YoYOptionletVolatilitySurface_baseDate, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_timeFromBase", _wrap_YoYOptionletVolatilitySurface_timeFromBase, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurface_minStrike", _wrap_YoYOptionletVolatilitySurface_minStrike, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_maxStrike", _wrap_YoYOptionletVolatilitySurface_maxStrike, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_baseLevel", _wrap_YoYOptionletVolatilitySurface_baseLevel, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_volatility", _wrap_YoYOptionletVolatilitySurface_volatility, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurface_totalVariance", _wrap_YoYOptionletVolatilitySurface_totalVariance, METH_VARARGS, NULL},
	 { "delete_YoYOptionletVolatilitySurface", _wrap_delete_YoYOptionletVolatilitySurface, METH_O, NULL},
	 { "YoYOptionletVolatilitySurface_swigregister", YoYOptionletVolatilitySurface_swigregister, METH_O, NULL},
	 { "new_YoYOptionletVolatilitySurfaceHandle", _wrap_new_YoYOptionletVolatilitySurfaceHandle, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle___deref__", _wrap_YoYOptionletVolatilitySurfaceHandle___deref__, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_currentLink", _wrap_YoYOptionletVolatilitySurfaceHandle_currentLink, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle___nonzero__", _wrap_YoYOptionletVolatilitySurfaceHandle___nonzero__, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle___bool__", _wrap_YoYOptionletVolatilitySurfaceHandle___bool__, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_asObservable", _wrap_YoYOptionletVolatilitySurfaceHandle_asObservable, METH_O, NULL},
	 { "delete_YoYOptionletVolatilitySurfaceHandle", _wrap_delete_YoYOptionletVolatilitySurfaceHandle, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_observationLag", _wrap_YoYOptionletVolatilitySurfaceHandle_observationLag, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_frequency", _wrap_YoYOptionletVolatilitySurfaceHandle_frequency, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated", _wrap_YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_baseDate", _wrap_YoYOptionletVolatilitySurfaceHandle_baseDate, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_timeFromBase", _wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_minStrike", _wrap_YoYOptionletVolatilitySurfaceHandle_minStrike, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_maxStrike", _wrap_YoYOptionletVolatilitySurfaceHandle_maxStrike, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_baseLevel", _wrap_YoYOptionletVolatilitySurfaceHandle_baseLevel, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_volatility", _wrap_YoYOptionletVolatilitySurfaceHandle_volatility, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_totalVariance", _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_dayCounter", _wrap_YoYOptionletVolatilitySurfaceHandle_dayCounter, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_timeFromReference", _wrap_YoYOptionletVolatilitySurfaceHandle_timeFromReference, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_calendar", _wrap_YoYOptionletVolatilitySurfaceHandle_calendar, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_referenceDate", _wrap_YoYOptionletVolatilitySurfaceHandle_referenceDate, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_maxDate", _wrap_YoYOptionletVolatilitySurfaceHandle_maxDate, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_maxTime", _wrap_YoYOptionletVolatilitySurfaceHandle_maxTime, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_enableExtrapolation", _wrap_YoYOptionletVolatilitySurfaceHandle_enableExtrapolation, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_disableExtrapolation", _wrap_YoYOptionletVolatilitySurfaceHandle_disableExtrapolation, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation", _wrap_YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_swigregister", YoYOptionletVolatilitySurfaceHandle_swigregister, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_swiginit", YoYOptionletVolatilitySurfaceHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableYoYOptionletVolatilitySurface", _wrap_new_RelinkableYoYOptionletVolatilitySurface, METH_VARARGS, NULL},
	 { "RelinkableYoYOptionletVolatilitySurface_linkTo", _wrap_RelinkableYoYOptionletVolatilitySurface_linkTo, METH_VARARGS, NULL},
	 { "RelinkableYoYOptionletVolatilitySurface_reset", _wrap_RelinkableYoYOptionletVolatilitySurface_reset, METH_O, NULL},
	 { "delete_RelinkableYoYOptionletVolatilitySurface", _wrap_delete_RelinkableYoYOptionletVolatilitySurface, METH_O, NULL},
	 { "RelinkableYoYOptionletVolatilitySurface_swigregister", RelinkableYoYOptionletVolatilitySurface_swigregister, METH_O, NULL},
	 { "RelinkableYoYOptionletVolatilitySurface_swiginit", RelinkableYoYOptionletVolatilitySurface_swiginit, METH_VARARGS, NULL},
	 { "SmileSection_minStrike", _wrap_SmileSection_minStrike, METH_O, NULL},
	 { "SmileSection_maxStrike", _wrap_SmileSection_maxStrike, METH_O, NULL},
	 { "SmileSection_atmLevel", _wrap_SmileSection_atmLevel, METH_O, NULL},
	 { "SmileSection_variance", _wrap_SmileSection_variance, METH_VARARGS, NULL},
	 { "SmileSection_exerciseDate", _wrap_SmileSection_exerciseDate, METH_O, NULL},
	 { "SmileSection_volatilityType", _wrap_SmileSection_volatilityType, METH_O, NULL},
	 { "SmileSection_shift", _wrap_SmileSection_shift, METH_O, NULL},
	 { "SmileSection_referenceDate", _wrap_SmileSection_referenceDate, METH_O, NULL},
	 { "SmileSection_exerciseTime", _wrap_SmileSection_exerciseTime, METH_O, NULL},
	 { "SmileSection_dayCounter", _wrap_SmileSection_dayCounter, METH_O, NULL},
	 { "SmileSection_optionPrice", _wrap_SmileSection_optionPrice, METH_VARARGS, NULL},
	 { "SmileSection_digitalOptionPrice", _wrap_SmileSection_digitalOptionPrice, METH_VARARGS, NULL},
	 { "SmileSection_vega", _wrap_SmileSection_vega, METH_VARARGS, NULL},
	 { "SmileSection_density", _wrap_SmileSection_density, METH_VARARGS, NULL},
	 { "SmileSection_volatility", _wrap_SmileSection_volatility, METH_VARARGS, NULL},
	 { "delete_SmileSection", _wrap_delete_SmileSection, METH_O, NULL},
	 { "SmileSection_swigregister", SmileSection_swigregister, METH_O, NULL},
	 { "SmileSectionVector_iterator", _wrap_SmileSectionVector_iterator, METH_O, NULL},
	 { "SmileSectionVector___nonzero__", _wrap_SmileSectionVector___nonzero__, METH_O, NULL},
	 { "SmileSectionVector___bool__", _wrap_SmileSectionVector___bool__, METH_O, NULL},
	 { "SmileSectionVector___len__", _wrap_SmileSectionVector___len__, METH_O, NULL},
	 { "SmileSectionVector___getslice__", _wrap_SmileSectionVector___getslice__, METH_VARARGS, NULL},
	 { "SmileSectionVector___setslice__", _wrap_SmileSectionVector___setslice__, METH_VARARGS, NULL},
	 { "SmileSectionVector___delslice__", _wrap_SmileSectionVector___delslice__, METH_VARARGS, NULL},
	 { "SmileSectionVector___delitem__", _wrap_SmileSectionVector___delitem__, METH_VARARGS, NULL},
	 { "SmileSectionVector___getitem__", _wrap_SmileSectionVector___getitem__, METH_VARARGS, NULL},
	 { "SmileSectionVector___setitem__", _wrap_SmileSectionVector___setitem__, METH_VARARGS, NULL},
	 { "SmileSectionVector_pop", _wrap_SmileSectionVector_pop, METH_O, NULL},
	 { "SmileSectionVector_append", _wrap_SmileSectionVector_append, METH_VARARGS, NULL},
	 { "SmileSectionVector_empty", _wrap_SmileSectionVector_empty, METH_O, NULL},
	 { "SmileSectionVector_size", _wrap_SmileSectionVector_size, METH_O, NULL},
	 { "SmileSectionVector_swap", _wrap_SmileSectionVector_swap, METH_VARARGS, NULL},
	 { "SmileSectionVector_begin", _wrap_SmileSectionVector_begin, METH_O, NULL},
	 { "SmileSectionVector_end", _wrap_SmileSectionVector_end, METH_O, NULL},
	 { "SmileSectionVector_rbegin", _wrap_SmileSectionVector_rbegin, METH_O, NULL},
	 { "SmileSectionVector_rend", _wrap_SmileSectionVector_rend, METH_O, NULL},
	 { "SmileSectionVector_clear", _wrap_SmileSectionVector_clear, METH_O, NULL},
	 { "SmileSectionVector_get_allocator", _wrap_SmileSectionVector_get_allocator, METH_O, NULL},
	 { "SmileSectionVector_pop_back", _wrap_SmileSectionVector_pop_back, METH_O, NULL},
	 { "SmileSectionVector_erase", _wrap_SmileSectionVector_erase, METH_VARARGS, NULL},
	 { "new_SmileSectionVector", _wrap_new_SmileSectionVector, METH_VARARGS, NULL},
	 { "SmileSectionVector_push_back", _wrap_SmileSectionVector_push_back, METH_VARARGS, NULL},
	 { "SmileSectionVector_front", _wrap_SmileSectionVector_front, METH_O, NULL},
	 { "SmileSectionVector_back", _wrap_SmileSectionVector_back, METH_O, NULL},
	 { "SmileSectionVector_assign", _wrap_SmileSectionVector_assign, METH_VARARGS, NULL},
	 { "SmileSectionVector_resize", _wrap_SmileSectionVector_resize, METH_VARARGS, NULL},
	 { "SmileSectionVector_insert", _wrap_SmileSectionVector_insert, METH_VARARGS, NULL},
	 { "SmileSectionVector_reserve", _wrap_SmileSectionVector_reserve, METH_VARARGS, NULL},
	 { "SmileSectionVector_capacity", _wrap_SmileSectionVector_capacity, METH_O, NULL},
	 { "delete_SmileSectionVector", _wrap_delete_SmileSectionVector, METH_O, NULL},
	 { "SmileSectionVector_swigregister", SmileSectionVector_swigregister, METH_O, NULL},
	 { "SmileSectionVector_swiginit", SmileSectionVector_swiginit, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructure_volatility", _wrap_SwaptionVolatilityStructure_volatility, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructure_blackVariance", _wrap_SwaptionVolatilityStructure_blackVariance, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructure_optionDateFromTenor", _wrap_SwaptionVolatilityStructure_optionDateFromTenor, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructure_shift", _wrap_SwaptionVolatilityStructure_shift, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructure_smileSection", _wrap_SwaptionVolatilityStructure_smileSection, METH_VARARGS, NULL},
	 { "delete_SwaptionVolatilityStructure", _wrap_delete_SwaptionVolatilityStructure, METH_O, NULL},
	 { "SwaptionVolatilityStructure_swigregister", SwaptionVolatilityStructure_swigregister, METH_O, NULL},
	 { "new_SwaptionVolatilityStructureHandle", _wrap_new_SwaptionVolatilityStructureHandle, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle___deref__", _wrap_SwaptionVolatilityStructureHandle___deref__, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_currentLink", _wrap_SwaptionVolatilityStructureHandle_currentLink, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle___nonzero__", _wrap_SwaptionVolatilityStructureHandle___nonzero__, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle___bool__", _wrap_SwaptionVolatilityStructureHandle___bool__, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_asObservable", _wrap_SwaptionVolatilityStructureHandle_asObservable, METH_O, NULL},
	 { "delete_SwaptionVolatilityStructureHandle", _wrap_delete_SwaptionVolatilityStructureHandle, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_volatility", _wrap_SwaptionVolatilityStructureHandle_volatility, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle_blackVariance", _wrap_SwaptionVolatilityStructureHandle_blackVariance, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle_optionDateFromTenor", _wrap_SwaptionVolatilityStructureHandle_optionDateFromTenor, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle_shift", _wrap_SwaptionVolatilityStructureHandle_shift, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle_smileSection", _wrap_SwaptionVolatilityStructureHandle_smileSection, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle_minStrike", _wrap_SwaptionVolatilityStructureHandle_minStrike, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_maxStrike", _wrap_SwaptionVolatilityStructureHandle_maxStrike, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_dayCounter", _wrap_SwaptionVolatilityStructureHandle_dayCounter, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_timeFromReference", _wrap_SwaptionVolatilityStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructureHandle_calendar", _wrap_SwaptionVolatilityStructureHandle_calendar, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_referenceDate", _wrap_SwaptionVolatilityStructureHandle_referenceDate, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_maxDate", _wrap_SwaptionVolatilityStructureHandle_maxDate, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_maxTime", _wrap_SwaptionVolatilityStructureHandle_maxTime, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_enableExtrapolation", _wrap_SwaptionVolatilityStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_disableExtrapolation", _wrap_SwaptionVolatilityStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_allowsExtrapolation", _wrap_SwaptionVolatilityStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_swigregister", SwaptionVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_swiginit", SwaptionVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableSwaptionVolatilityStructureHandle", _wrap_new_RelinkableSwaptionVolatilityStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableSwaptionVolatilityStructureHandle_linkTo", _wrap_RelinkableSwaptionVolatilityStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableSwaptionVolatilityStructureHandle_reset", _wrap_RelinkableSwaptionVolatilityStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableSwaptionVolatilityStructureHandle", _wrap_delete_RelinkableSwaptionVolatilityStructureHandle, METH_O, NULL},
	 { "RelinkableSwaptionVolatilityStructureHandle_swigregister", RelinkableSwaptionVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableSwaptionVolatilityStructureHandle_swiginit", RelinkableSwaptionVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_BlackConstantVol", _wrap_new_BlackConstantVol, METH_VARARGS, NULL},
	 { "delete_BlackConstantVol", _wrap_delete_BlackConstantVol, METH_O, NULL},
	 { "BlackConstantVol_swigregister", BlackConstantVol_swigregister, METH_O, NULL},
	 { "BlackConstantVol_swiginit", BlackConstantVol_swiginit, METH_VARARGS, NULL},
	 { "new_BlackVarianceCurve", _wrap_new_BlackVarianceCurve, METH_VARARGS, NULL},
	 { "delete_BlackVarianceCurve", _wrap_delete_BlackVarianceCurve, METH_O, NULL},
	 { "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, NULL},
	 { "BlackVarianceSurface_setInterpolation", _wrap_BlackVarianceSurface_setInterpolation, METH_VARARGS, NULL},
	 { "delete_BlackVarianceSurface", _wrap_delete_BlackVarianceSurface, METH_O, NULL},
	 { "BlackVarianceSurface_swigregister", BlackVarianceSurface_swigregister, METH_O, NULL},
	 { "BlackVarianceSurface_swiginit", BlackVarianceSurface_swiginit, METH_VARARGS, NULL},
	 { "new_LocalConstantVol", _wrap_new_LocalConstantVol, METH_VARARGS, NULL},
	 { "delete_LocalConstantVol", _wrap_delete_LocalConstantVol, METH_O, NULL},
	 { "LocalConstantVol_swigregister", LocalConstantVol_swigregister, METH_O, NULL},
	 { "LocalConstantVol_swiginit", LocalConstantVol_swiginit, METH_VARARGS, NULL},
	 { "new_LocalVolSurface", _wrap_new_LocalVolSurface, METH_VARARGS, NULL},
	 { "delete_LocalVolSurface", _wrap_delete_LocalVolSurface, METH_O, NULL},
	 { "LocalVolSurface_swigregister", LocalVolSurface_swigregister, METH_O, NULL},
	 { "LocalVolSurface_swiginit", LocalVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_NoExceptLocalVolSurface", _wrap_new_NoExceptLocalVolSurface, METH_VARARGS, NULL},
	 { "delete_NoExceptLocalVolSurface", _wrap_delete_NoExceptLocalVolSurface, METH_O, NULL},
	 { "NoExceptLocalVolSurface_swigregister", NoExceptLocalVolSurface_swigregister, METH_O, NULL},
	 { "NoExceptLocalVolSurface_swiginit", NoExceptLocalVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantOptionletVolatility", _wrap_new_ConstantOptionletVolatility, METH_VARARGS, NULL},
	 { "delete_ConstantOptionletVolatility", _wrap_delete_ConstantOptionletVolatility, METH_O, NULL},
	 { "ConstantOptionletVolatility_swigregister", ConstantOptionletVolatility_swigregister, METH_O, NULL},
	 { "ConstantOptionletVolatility_swiginit", ConstantOptionletVolatility_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantSwaptionVolatility", _wrap_new_ConstantSwaptionVolatility, METH_VARARGS, NULL},
	 { "delete_ConstantSwaptionVolatility", _wrap_delete_ConstantSwaptionVolatility, METH_O, NULL},
	 { "ConstantSwaptionVolatility_swigregister", ConstantSwaptionVolatility_swigregister, METH_O, NULL},
	 { "ConstantSwaptionVolatility_swiginit", ConstantSwaptionVolatility_swiginit, METH_VARARGS, NULL},
	 { "SwaptionVolatilityDiscrete_optionTenors", _wrap_SwaptionVolatilityDiscrete_optionTenors, METH_O, NULL},
	 { "SwaptionVolatilityDiscrete_optionDates", _wrap_SwaptionVolatilityDiscrete_optionDates, METH_O, NULL},
	 { "SwaptionVolatilityDiscrete_optionTimes", _wrap_SwaptionVolatilityDiscrete_optionTimes, METH_O, NULL},
	 { "SwaptionVolatilityDiscrete_swapTenors", _wrap_SwaptionVolatilityDiscrete_swapTenors, METH_O, NULL},
	 { "SwaptionVolatilityDiscrete_swapLengths", _wrap_SwaptionVolatilityDiscrete_swapLengths, METH_O, NULL},
	 { "SwaptionVolatilityDiscrete_optionDateFromTime", _wrap_SwaptionVolatilityDiscrete_optionDateFromTime, METH_VARARGS, NULL},
	 { "delete_SwaptionVolatilityDiscrete", _wrap_delete_SwaptionVolatilityDiscrete, METH_O, NULL},
	 { "SwaptionVolatilityDiscrete_swigregister", SwaptionVolatilityDiscrete_swigregister, METH_O, NULL},
	 { "new_SwaptionVolatilityMatrix", _wrap_new_SwaptionVolatilityMatrix, METH_VARARGS, NULL},
	 { "SwaptionVolatilityMatrix_locate", _wrap_SwaptionVolatilityMatrix_locate, METH_VARARGS, NULL},
	 { "SwaptionVolatilityMatrix_volatilityType", _wrap_SwaptionVolatilityMatrix_volatilityType, METH_O, NULL},
	 { "delete_SwaptionVolatilityMatrix", _wrap_delete_SwaptionVolatilityMatrix, METH_O, NULL},
	 { "SwaptionVolatilityMatrix_swigregister", SwaptionVolatilityMatrix_swigregister, METH_O, NULL},
	 { "SwaptionVolatilityMatrix_swiginit", SwaptionVolatilityMatrix_swiginit, METH_VARARGS, NULL},
	 { "new_SabrSmileSection", _wrap_new_SabrSmileSection, METH_VARARGS, NULL},
	 { "SabrSmileSection_alpha", _wrap_SabrSmileSection_alpha, METH_O, NULL},
	 { "SabrSmileSection_beta", _wrap_SabrSmileSection_beta, METH_O, NULL},
	 { "SabrSmileSection_nu", _wrap_SabrSmileSection_nu, METH_O, NULL},
	 { "SabrSmileSection_rho", _wrap_SabrSmileSection_rho, METH_O, NULL},
	 { "delete_SabrSmileSection", _wrap_delete_SabrSmileSection, METH_O, NULL},
	 { "SabrSmileSection_swigregister", SabrSmileSection_swigregister, METH_O, NULL},
	 { "SabrSmileSection_swiginit", SabrSmileSection_swiginit, METH_VARARGS, NULL},
	 { "SwaptionVolatilityCube_atmStrike", _wrap_SwaptionVolatilityCube_atmStrike, METH_VARARGS, NULL},
	 { "delete_SwaptionVolatilityCube", _wrap_delete_SwaptionVolatilityCube, METH_O, NULL},
	 { "SwaptionVolatilityCube_swigregister", SwaptionVolatilityCube_swigregister, METH_O, NULL},
	 { "new_SwaptionVolCube1", _wrap_new_SwaptionVolCube1, METH_VARARGS, NULL},
	 { "SwaptionVolCube1_sparseSabrParameters", _wrap_SwaptionVolCube1_sparseSabrParameters, METH_O, NULL},
	 { "SwaptionVolCube1_denseSabrParameters", _wrap_SwaptionVolCube1_denseSabrParameters, METH_O, NULL},
	 { "SwaptionVolCube1_marketVolCube", _wrap_SwaptionVolCube1_marketVolCube, METH_O, NULL},
	 { "SwaptionVolCube1_volCubeAtmCalibrated", _wrap_SwaptionVolCube1_volCubeAtmCalibrated, METH_O, NULL},
	 { "SwaptionVolCube1_smileSection", _wrap_SwaptionVolCube1_smileSection, METH_VARARGS, NULL},
	 { "delete_SwaptionVolCube1", _wrap_delete_SwaptionVolCube1, METH_O, NULL},
	 { "SwaptionVolCube1_swigregister", SwaptionVolCube1_swigregister, METH_O, NULL},
	 { "SwaptionVolCube1_swiginit", SwaptionVolCube1_swiginit, METH_VARARGS, NULL},
	 { "new_SwaptionVolCube2", _wrap_new_SwaptionVolCube2, METH_VARARGS, NULL},
	 { "delete_SwaptionVolCube2", _wrap_delete_SwaptionVolCube2, METH_O, NULL},
	 { "SwaptionVolCube2_swigregister", SwaptionVolCube2_swigregister, METH_O, NULL},
	 { "SwaptionVolCube2_swiginit", SwaptionVolCube2_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantYoYOptionletVolatility", _wrap_new_ConstantYoYOptionletVolatility, METH_VARARGS, NULL},
	 { "delete_ConstantYoYOptionletVolatility", _wrap_delete_ConstantYoYOptionletVolatility, METH_O, NULL},
	 { "ConstantYoYOptionletVolatility_swigregister", ConstantYoYOptionletVolatility_swigregister, METH_O, NULL},
	 { "ConstantYoYOptionletVolatility_swiginit", ConstantYoYOptionletVolatility_swiginit, METH_VARARGS, NULL},
	 { "new_FlatSmileSection", _wrap_new_FlatSmileSection, METH_VARARGS, NULL},
	 { "delete_FlatSmileSection", _wrap_delete_FlatSmileSection, METH_O, NULL},
	 { "FlatSmileSection_swigregister", FlatSmileSection_swigregister, METH_O, NULL},
	 { "FlatSmileSection_swiginit", FlatSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_LinearInterpolatedSmileSection", _wrap_new_LinearInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "delete_LinearInterpolatedSmileSection", _wrap_delete_LinearInterpolatedSmileSection, METH_O, NULL},
	 { "LinearInterpolatedSmileSection_swigregister", LinearInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "LinearInterpolatedSmileSection_swiginit", LinearInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_CubicInterpolatedSmileSection", _wrap_new_CubicInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "delete_CubicInterpolatedSmileSection", _wrap_delete_CubicInterpolatedSmileSection, METH_O, NULL},
	 { "CubicInterpolatedSmileSection_swigregister", CubicInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "CubicInterpolatedSmileSection_swiginit", CubicInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubicInterpolatedSmileSection", _wrap_new_MonotonicCubicInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "delete_MonotonicCubicInterpolatedSmileSection", _wrap_delete_MonotonicCubicInterpolatedSmileSection, METH_O, NULL},
	 { "MonotonicCubicInterpolatedSmileSection_swigregister", MonotonicCubicInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "MonotonicCubicInterpolatedSmileSection_swiginit", MonotonicCubicInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_SplineCubicInterpolatedSmileSection", _wrap_new_SplineCubicInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "delete_SplineCubicInterpolatedSmileSection", _wrap_delete_SplineCubicInterpolatedSmileSection, METH_O, NULL},
	 { "SplineCubicInterpolatedSmileSection_swigregister", SplineCubicInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "SplineCubicInterpolatedSmileSection_swiginit", SplineCubicInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_KahaleSmileSection", _wrap_new_KahaleSmileSection, METH_VARARGS, NULL},
	 { "delete_KahaleSmileSection", _wrap_delete_KahaleSmileSection, METH_O, NULL},
	 { "KahaleSmileSection_swigregister", KahaleSmileSection_swigregister, METH_O, NULL},
	 { "KahaleSmileSection_swiginit", KahaleSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityLognormal", _wrap_new_ZabrShortMaturityLognormal, METH_NOARGS, NULL},
	 { "delete_ZabrShortMaturityLognormal", _wrap_delete_ZabrShortMaturityLognormal, METH_O, NULL},
	 { "ZabrShortMaturityLognormal_swigregister", ZabrShortMaturityLognormal_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityLognormal_swiginit", ZabrShortMaturityLognormal_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityNormal", _wrap_new_ZabrShortMaturityNormal, METH_NOARGS, NULL},
	 { "delete_ZabrShortMaturityNormal", _wrap_delete_ZabrShortMaturityNormal, METH_O, NULL},
	 { "ZabrShortMaturityNormal_swigregister", ZabrShortMaturityNormal_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityNormal_swiginit", ZabrShortMaturityNormal_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrLocalVolatility", _wrap_new_ZabrLocalVolatility, METH_NOARGS, NULL},
	 { "delete_ZabrLocalVolatility", _wrap_delete_ZabrLocalVolatility, METH_O, NULL},
	 { "ZabrLocalVolatility_swigregister", ZabrLocalVolatility_swigregister, METH_O, NULL},
	 { "ZabrLocalVolatility_swiginit", ZabrLocalVolatility_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrFullFd", _wrap_new_ZabrFullFd, METH_NOARGS, NULL},
	 { "delete_ZabrFullFd", _wrap_delete_ZabrFullFd, METH_O, NULL},
	 { "ZabrFullFd_swigregister", ZabrFullFd_swigregister, METH_O, NULL},
	 { "ZabrFullFd_swiginit", ZabrFullFd_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityLognormalSmileSection", _wrap_new_ZabrShortMaturityLognormalSmileSection, METH_VARARGS, NULL},
	 { "delete_ZabrShortMaturityLognormalSmileSection", _wrap_delete_ZabrShortMaturityLognormalSmileSection, METH_O, NULL},
	 { "ZabrShortMaturityLognormalSmileSection_swigregister", ZabrShortMaturityLognormalSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityLognormalSmileSection_swiginit", ZabrShortMaturityLognormalSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityNormalSmileSection", _wrap_new_ZabrShortMaturityNormalSmileSection, METH_VARARGS, NULL},
	 { "delete_ZabrShortMaturityNormalSmileSection", _wrap_delete_ZabrShortMaturityNormalSmileSection, METH_O, NULL},
	 { "ZabrShortMaturityNormalSmileSection_swigregister", ZabrShortMaturityNormalSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityNormalSmileSection_swiginit", ZabrShortMaturityNormalSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrLocalVolatilitySmileSection", _wrap_new_ZabrLocalVolatilitySmileSection, METH_VARARGS, NULL},
	 { "delete_ZabrLocalVolatilitySmileSection", _wrap_delete_ZabrLocalVolatilitySmileSection, METH_O, NULL},
	 { "ZabrLocalVolatilitySmileSection_swigregister", ZabrLocalVolatilitySmileSection_swigregister, METH_O, NULL},
	 { "ZabrLocalVolatilitySmileSection_swiginit", ZabrLocalVolatilitySmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrFullFdSmileSection", _wrap_new_ZabrFullFdSmileSection, METH_VARARGS, NULL},
	 { "delete_ZabrFullFdSmileSection", _wrap_delete_ZabrFullFdSmileSection, METH_O, NULL},
	 { "ZabrFullFdSmileSection_swigregister", ZabrFullFdSmileSection_swigregister, METH_O, NULL},
	 { "ZabrFullFdSmileSection_swiginit", ZabrFullFdSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityLognormalInterpolatedSmileSection", _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_alpha", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_alpha, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_beta", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_beta, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_nu", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_nu, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_rho", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_rho, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_maxError", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_maxError, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria, METH_O, NULL},
	 { "delete_ZabrShortMaturityLognormalInterpolatedSmileSection", _wrap_delete_ZabrShortMaturityLognormalInterpolatedSmileSection, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister", ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit", ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityNormalInterpolatedSmileSection", _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_alpha", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_alpha, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_beta", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_beta, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_nu", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_nu, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_rho", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_rho, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_rmsError", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_rmsError, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_maxError", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_maxError, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria, METH_O, NULL},
	 { "delete_ZabrShortMaturityNormalInterpolatedSmileSection", _wrap_delete_ZabrShortMaturityNormalInterpolatedSmileSection, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_swigregister", ZabrShortMaturityNormalInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_swiginit", ZabrShortMaturityNormalInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrLocalVolatilityInterpolatedSmileSection", _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_alpha", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_alpha, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_beta", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_beta, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_nu", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_nu, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_rho", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_rho, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_rmsError", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_rmsError, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_maxError", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_maxError, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_endCriteria", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_endCriteria, METH_O, NULL},
	 { "delete_ZabrLocalVolatilityInterpolatedSmileSection", _wrap_delete_ZabrLocalVolatilityInterpolatedSmileSection, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_swigregister", ZabrLocalVolatilityInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_swiginit", ZabrLocalVolatilityInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrFullFdInterpolatedSmileSection", _wrap_new_ZabrFullFdInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_alpha", _wrap_ZabrFullFdInterpolatedSmileSection_alpha, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_beta", _wrap_ZabrFullFdInterpolatedSmileSection_beta, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_nu", _wrap_ZabrFullFdInterpolatedSmileSection_nu, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_rho", _wrap_ZabrFullFdInterpolatedSmileSection_rho, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_rmsError", _wrap_ZabrFullFdInterpolatedSmileSection_rmsError, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_maxError", _wrap_ZabrFullFdInterpolatedSmileSection_maxError, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_endCriteria", _wrap_ZabrFullFdInterpolatedSmileSection_endCriteria, METH_O, NULL},
	 { "delete_ZabrFullFdInterpolatedSmileSection", _wrap_delete_ZabrFullFdInterpolatedSmileSection, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_swigregister", ZabrFullFdInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_swiginit", ZabrFullFdInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_NoArbSabrSmileSection", _wrap_new_NoArbSabrSmileSection, METH_VARARGS, NULL},
	 { "delete_NoArbSabrSmileSection", _wrap_delete_NoArbSabrSmileSection, METH_O, NULL},
	 { "NoArbSabrSmileSection_swigregister", NoArbSabrSmileSection_swigregister, METH_O, NULL},
	 { "NoArbSabrSmileSection_swiginit", NoArbSabrSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_NoArbSabrInterpolatedSmileSection", _wrap_new_NoArbSabrInterpolatedSmileSection, METH_VARARGS, NULL},
	 { "NoArbSabrInterpolatedSmileSection_alpha", _wrap_NoArbSabrInterpolatedSmileSection_alpha, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_beta", _wrap_NoArbSabrInterpolatedSmileSection_beta, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_nu", _wrap_NoArbSabrInterpolatedSmileSection_nu, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_rho", _wrap_NoArbSabrInterpolatedSmileSection_rho, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_rmsError", _wrap_NoArbSabrInterpolatedSmileSection_rmsError, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_maxError", _wrap_NoArbSabrInterpolatedSmileSection_maxError, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_endCriteria", _wrap_NoArbSabrInterpolatedSmileSection_endCriteria, METH_O, NULL},
	 { "delete_NoArbSabrInterpolatedSmileSection", _wrap_delete_NoArbSabrInterpolatedSmileSection, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_swigregister", NoArbSabrInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_swiginit", NoArbSabrInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "sabrVolatility", _wrap_sabrVolatility, METH_VARARGS, NULL},
	 { "shiftedSabrVolatility", _wrap_shiftedSabrVolatility, METH_VARARGS, NULL},
	 { "sabrFlochKennedyVolatility", _wrap_sabrFlochKennedyVolatility, METH_VARARGS, NULL},
	 { "new_CalibrationErrorTuple", _wrap_new_CalibrationErrorTuple, METH_VARARGS, NULL},
	 { "CalibrationErrorTuple_first", _wrap_CalibrationErrorTuple_first, METH_O, NULL},
	 { "CalibrationErrorTuple_second", _wrap_CalibrationErrorTuple_second, METH_O, NULL},
	 { "CalibrationErrorTuple_third", _wrap_CalibrationErrorTuple_third, METH_O, NULL},
	 { "delete_CalibrationErrorTuple", _wrap_delete_CalibrationErrorTuple, METH_O, NULL},
	 { "CalibrationErrorTuple_swigregister", CalibrationErrorTuple_swigregister, METH_O, NULL},
	 { "CalibrationErrorTuple_swiginit", CalibrationErrorTuple_swiginit, METH_VARARGS, NULL},
	 { "new_AndreasenHugeVolatilityInterpl", _wrap_new_AndreasenHugeVolatilityInterpl, METH_VARARGS, NULL},
	 { "AndreasenHugeVolatilityInterpl_maxDate", _wrap_AndreasenHugeVolatilityInterpl_maxDate, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_minStrike", _wrap_AndreasenHugeVolatilityInterpl_minStrike, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_maxStrike", _wrap_AndreasenHugeVolatilityInterpl_maxStrike, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_fwd", _wrap_AndreasenHugeVolatilityInterpl_fwd, METH_VARARGS, NULL},
	 { "AndreasenHugeVolatilityInterpl_riskFreeRate", _wrap_AndreasenHugeVolatilityInterpl_riskFreeRate, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_calibrationError", _wrap_AndreasenHugeVolatilityInterpl_calibrationError, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_optionPrice", _wrap_AndreasenHugeVolatilityInterpl_optionPrice, METH_VARARGS, NULL},
	 { "AndreasenHugeVolatilityInterpl_localVol", _wrap_AndreasenHugeVolatilityInterpl_localVol, METH_VARARGS, NULL},
	 { "delete_AndreasenHugeVolatilityInterpl", _wrap_delete_AndreasenHugeVolatilityInterpl, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_swigregister", AndreasenHugeVolatilityInterpl_swigregister, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_swiginit", AndreasenHugeVolatilityInterpl_swiginit, METH_VARARGS, NULL},
	 { "new_AndreasenHugeVolatilityAdapter", _wrap_new_AndreasenHugeVolatilityAdapter, METH_VARARGS, NULL},
	 { "delete_AndreasenHugeVolatilityAdapter", _wrap_delete_AndreasenHugeVolatilityAdapter, METH_O, NULL},
	 { "AndreasenHugeVolatilityAdapter_swigregister", AndreasenHugeVolatilityAdapter_swigregister, METH_O, NULL},
	 { "AndreasenHugeVolatilityAdapter_swiginit", AndreasenHugeVolatilityAdapter_swiginit, METH_VARARGS, NULL},
	 { "new_AndreasenHugeLocalVolAdapter", _wrap_new_AndreasenHugeLocalVolAdapter, METH_O, NULL},
	 { "delete_AndreasenHugeLocalVolAdapter", _wrap_delete_AndreasenHugeLocalVolAdapter, METH_O, NULL},
	 { "AndreasenHugeLocalVolAdapter_swigregister", AndreasenHugeLocalVolAdapter_swigregister, METH_O, NULL},
	 { "AndreasenHugeLocalVolAdapter_swiginit", AndreasenHugeLocalVolAdapter_swiginit, METH_VARARGS, NULL},
	 { "new_HestonBlackVolSurface", _wrap_new_HestonBlackVolSurface, METH_VARARGS, NULL},
	 { "delete_HestonBlackVolSurface", _wrap_delete_HestonBlackVolSurface, METH_O, NULL},
	 { "HestonBlackVolSurface_swigregister", HestonBlackVolSurface_swigregister, METH_O, NULL},
	 { "HestonBlackVolSurface_swiginit", HestonBlackVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_CmsMarket", _wrap_new_CmsMarket, METH_VARARGS, NULL},
	 { "CmsMarket_reprice", _wrap_CmsMarket_reprice, METH_VARARGS, NULL},
	 { "CmsMarket_swapTenors", _wrap_CmsMarket_swapTenors, METH_O, NULL},
	 { "CmsMarket_swapLengths", _wrap_CmsMarket_swapLengths, METH_O, NULL},
	 { "CmsMarket_impliedCmsSpreads", _wrap_CmsMarket_impliedCmsSpreads, METH_O, NULL},
	 { "CmsMarket_spreadErrors", _wrap_CmsMarket_spreadErrors, METH_O, NULL},
	 { "CmsMarket_browse", _wrap_CmsMarket_browse, METH_O, NULL},
	 { "CmsMarket_weightedSpreadError", _wrap_CmsMarket_weightedSpreadError, METH_VARARGS, NULL},
	 { "CmsMarket_weightedSpotNpvError", _wrap_CmsMarket_weightedSpotNpvError, METH_VARARGS, NULL},
	 { "CmsMarket_weightedFwdNpvError", _wrap_CmsMarket_weightedFwdNpvError, METH_VARARGS, NULL},
	 { "CmsMarket_weightedSpreadErrors", _wrap_CmsMarket_weightedSpreadErrors, METH_VARARGS, NULL},
	 { "CmsMarket_weightedSpotNpvErrors", _wrap_CmsMarket_weightedSpotNpvErrors, METH_VARARGS, NULL},
	 { "CmsMarket_weightedFwdNpvErrors", _wrap_CmsMarket_weightedFwdNpvErrors, METH_VARARGS, NULL},
	 { "delete_CmsMarket", _wrap_delete_CmsMarket, METH_O, NULL},
	 { "CmsMarket_swigregister", CmsMarket_swigregister, METH_O, NULL},
	 { "CmsMarket_swiginit", CmsMarket_swiginit, METH_VARARGS, NULL},
	 { "new_CmsMarketCalibration", _wrap_new_CmsMarketCalibration, METH_VARARGS, NULL},
	 { "CmsMarketCalibration_compute", _wrap_CmsMarketCalibration_compute, METH_VARARGS, NULL},
	 { "CmsMarketCalibration_computeParametric", _wrap_CmsMarketCalibration_computeParametric, METH_VARARGS, NULL},
	 { "CmsMarketCalibration_error", _wrap_CmsMarketCalibration_error, METH_O, NULL},
	 { "CmsMarketCalibration_endCriteria", _wrap_CmsMarketCalibration_endCriteria, METH_O, NULL},
	 { "delete_CmsMarketCalibration", _wrap_delete_CmsMarketCalibration, METH_O, NULL},
	 { "CmsMarketCalibration_swigregister", CmsMarketCalibration_swigregister, METH_O, NULL},
	 { "CmsMarketCalibration_swiginit", CmsMarketCalibration_swiginit, METH_VARARGS, NULL},
	 { "StochasticProcess_size", _wrap_StochasticProcess_size, METH_O, NULL},
	 { "StochasticProcess_factors", _wrap_StochasticProcess_factors, METH_O, NULL},
	 { "StochasticProcess_initialValues", _wrap_StochasticProcess_initialValues, METH_O, NULL},
	 { "StochasticProcess_drift", _wrap_StochasticProcess_drift, METH_VARARGS, NULL},
	 { "StochasticProcess_diffusion", _wrap_StochasticProcess_diffusion, METH_VARARGS, NULL},
	 { "StochasticProcess_expectation", _wrap_StochasticProcess_expectation, METH_VARARGS, NULL},
	 { "StochasticProcess_stdDeviation", _wrap_StochasticProcess_stdDeviation, METH_VARARGS, NULL},
	 { "StochasticProcess_covariance", _wrap_StochasticProcess_covariance, METH_VARARGS, NULL},
	 { "StochasticProcess_evolve", _wrap_StochasticProcess_evolve, METH_VARARGS, NULL},
	 { "delete_StochasticProcess", _wrap_delete_StochasticProcess, METH_O, NULL},
	 { "StochasticProcess_swigregister", StochasticProcess_swigregister, METH_O, NULL},
	 { "StochasticProcessVector_iterator", _wrap_StochasticProcessVector_iterator, METH_O, NULL},
	 { "StochasticProcessVector___nonzero__", _wrap_StochasticProcessVector___nonzero__, METH_O, NULL},
	 { "StochasticProcessVector___bool__", _wrap_StochasticProcessVector___bool__, METH_O, NULL},
	 { "StochasticProcessVector___len__", _wrap_StochasticProcessVector___len__, METH_O, NULL},
	 { "StochasticProcessVector___getslice__", _wrap_StochasticProcessVector___getslice__, METH_VARARGS, NULL},
	 { "StochasticProcessVector___setslice__", _wrap_StochasticProcessVector___setslice__, METH_VARARGS, NULL},
	 { "StochasticProcessVector___delslice__", _wrap_StochasticProcessVector___delslice__, METH_VARARGS, NULL},
	 { "StochasticProcessVector___delitem__", _wrap_StochasticProcessVector___delitem__, METH_VARARGS, NULL},
	 { "StochasticProcessVector___getitem__", _wrap_StochasticProcessVector___getitem__, METH_VARARGS, NULL},
	 { "StochasticProcessVector___setitem__", _wrap_StochasticProcessVector___setitem__, METH_VARARGS, NULL},
	 { "StochasticProcessVector_pop", _wrap_StochasticProcessVector_pop, METH_O, NULL},
	 { "StochasticProcessVector_append", _wrap_StochasticProcessVector_append, METH_VARARGS, NULL},
	 { "StochasticProcessVector_empty", _wrap_StochasticProcessVector_empty, METH_O, NULL},
	 { "StochasticProcessVector_size", _wrap_StochasticProcessVector_size, METH_O, NULL},
	 { "StochasticProcessVector_swap", _wrap_StochasticProcessVector_swap, METH_VARARGS, NULL},
	 { "StochasticProcessVector_begin", _wrap_StochasticProcessVector_begin, METH_O, NULL},
	 { "StochasticProcessVector_end", _wrap_StochasticProcessVector_end, METH_O, NULL},
	 { "StochasticProcessVector_rbegin", _wrap_StochasticProcessVector_rbegin, METH_O, NULL},
	 { "StochasticProcessVector_rend", _wrap_StochasticProcessVector_rend, METH_O, NULL},
	 { "StochasticProcessVector_clear", _wrap_StochasticProcessVector_clear, METH_O, NULL},
	 { "StochasticProcessVector_get_allocator", _wrap_StochasticProcessVector_get_allocator, METH_O, NULL},
	 { "StochasticProcessVector_pop_back", _wrap_StochasticProcessVector_pop_back, METH_O, NULL},
	 { "StochasticProcessVector_erase", _wrap_StochasticProcessVector_erase, METH_VARARGS, NULL},
	 { "new_StochasticProcessVector", _wrap_new_StochasticProcessVector, METH_VARARGS, NULL},
	 { "StochasticProcessVector_push_back", _wrap_StochasticProcessVector_push_back, METH_VARARGS, NULL},
	 { "StochasticProcessVector_front", _wrap_StochasticProcessVector_front, METH_O, NULL},
	 { "StochasticProcessVector_back", _wrap_StochasticProcessVector_back, METH_O, NULL},
	 { "StochasticProcessVector_assign", _wrap_StochasticProcessVector_assign, METH_VARARGS, NULL},
	 { "StochasticProcessVector_resize", _wrap_StochasticProcessVector_resize, METH_VARARGS, NULL},
	 { "StochasticProcessVector_insert", _wrap_StochasticProcessVector_insert, METH_VARARGS, NULL},
	 { "StochasticProcessVector_reserve", _wrap_StochasticProcessVector_reserve, METH_VARARGS, NULL},
	 { "StochasticProcessVector_capacity", _wrap_StochasticProcessVector_capacity, METH_O, NULL},
	 { "delete_StochasticProcessVector", _wrap_delete_StochasticProcessVector, METH_O, NULL},
	 { "StochasticProcessVector_swigregister", StochasticProcessVector_swigregister, METH_O, NULL},
	 { "StochasticProcessVector_swiginit", StochasticProcessVector_swiginit, METH_VARARGS, NULL},
	 { "StochasticProcess1D_x0", _wrap_StochasticProcess1D_x0, METH_O, NULL},
	 { "StochasticProcess1D_drift", _wrap_StochasticProcess1D_drift, METH_VARARGS, NULL},
	 { "StochasticProcess1D_diffusion", _wrap_StochasticProcess1D_diffusion, METH_VARARGS, NULL},
	 { "StochasticProcess1D_expectation", _wrap_StochasticProcess1D_expectation, METH_VARARGS, NULL},
	 { "StochasticProcess1D_stdDeviation", _wrap_StochasticProcess1D_stdDeviation, METH_VARARGS, NULL},
	 { "StochasticProcess1D_variance", _wrap_StochasticProcess1D_variance, METH_VARARGS, NULL},
	 { "StochasticProcess1D_evolve", _wrap_StochasticProcess1D_evolve, METH_VARARGS, NULL},
	 { "StochasticProcess1D_apply", _wrap_StochasticProcess1D_apply, METH_VARARGS, NULL},
	 { "delete_StochasticProcess1D", _wrap_delete_StochasticProcess1D, METH_O, NULL},
	 { "StochasticProcess1D_swigregister", StochasticProcess1D_swigregister, METH_O, NULL},
	 { "StochasticProcess1DVector_iterator", _wrap_StochasticProcess1DVector_iterator, METH_O, NULL},
	 { "StochasticProcess1DVector___nonzero__", _wrap_StochasticProcess1DVector___nonzero__, METH_O, NULL},
	 { "StochasticProcess1DVector___bool__", _wrap_StochasticProcess1DVector___bool__, METH_O, NULL},
	 { "StochasticProcess1DVector___len__", _wrap_StochasticProcess1DVector___len__, METH_O, NULL},
	 { "StochasticProcess1DVector___getslice__", _wrap_StochasticProcess1DVector___getslice__, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector___setslice__", _wrap_StochasticProcess1DVector___setslice__, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector___delslice__", _wrap_StochasticProcess1DVector___delslice__, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector___delitem__", _wrap_StochasticProcess1DVector___delitem__, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector___getitem__", _wrap_StochasticProcess1DVector___getitem__, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector___setitem__", _wrap_StochasticProcess1DVector___setitem__, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_pop", _wrap_StochasticProcess1DVector_pop, METH_O, NULL},
	 { "StochasticProcess1DVector_append", _wrap_StochasticProcess1DVector_append, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_empty", _wrap_StochasticProcess1DVector_empty, METH_O, NULL},
	 { "StochasticProcess1DVector_size", _wrap_StochasticProcess1DVector_size, METH_O, NULL},
	 { "StochasticProcess1DVector_swap", _wrap_StochasticProcess1DVector_swap, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_begin", _wrap_StochasticProcess1DVector_begin, METH_O, NULL},
	 { "StochasticProcess1DVector_end", _wrap_StochasticProcess1DVector_end, METH_O, NULL},
	 { "StochasticProcess1DVector_rbegin", _wrap_StochasticProcess1DVector_rbegin, METH_O, NULL},
	 { "StochasticProcess1DVector_rend", _wrap_StochasticProcess1DVector_rend, METH_O, NULL},
	 { "StochasticProcess1DVector_clear", _wrap_StochasticProcess1DVector_clear, METH_O, NULL},
	 { "StochasticProcess1DVector_get_allocator", _wrap_StochasticProcess1DVector_get_allocator, METH_O, NULL},
	 { "StochasticProcess1DVector_pop_back", _wrap_StochasticProcess1DVector_pop_back, METH_O, NULL},
	 { "StochasticProcess1DVector_erase", _wrap_StochasticProcess1DVector_erase, METH_VARARGS, NULL},
	 { "new_StochasticProcess1DVector", _wrap_new_StochasticProcess1DVector, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_push_back", _wrap_StochasticProcess1DVector_push_back, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_front", _wrap_StochasticProcess1DVector_front, METH_O, NULL},
	 { "StochasticProcess1DVector_back", _wrap_StochasticProcess1DVector_back, METH_O, NULL},
	 { "StochasticProcess1DVector_assign", _wrap_StochasticProcess1DVector_assign, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_resize", _wrap_StochasticProcess1DVector_resize, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_insert", _wrap_StochasticProcess1DVector_insert, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_reserve", _wrap_StochasticProcess1DVector_reserve, METH_VARARGS, NULL},
	 { "StochasticProcess1DVector_capacity", _wrap_StochasticProcess1DVector_capacity, METH_O, NULL},
	 { "delete_StochasticProcess1DVector", _wrap_delete_StochasticProcess1DVector, METH_O, NULL},
	 { "StochasticProcess1DVector_swigregister", StochasticProcess1DVector_swigregister, METH_O, NULL},
	 { "StochasticProcess1DVector_swiginit", StochasticProcess1DVector_swiginit, METH_VARARGS, NULL},
	 { "new_GeneralizedBlackScholesProcess", _wrap_new_GeneralizedBlackScholesProcess, METH_VARARGS, NULL},
	 { "GeneralizedBlackScholesProcess_stateVariable", _wrap_GeneralizedBlackScholesProcess_stateVariable, METH_O, NULL},
	 { "GeneralizedBlackScholesProcess_dividendYield", _wrap_GeneralizedBlackScholesProcess_dividendYield, METH_O, NULL},
	 { "GeneralizedBlackScholesProcess_riskFreeRate", _wrap_GeneralizedBlackScholesProcess_riskFreeRate, METH_O, NULL},
	 { "GeneralizedBlackScholesProcess_blackVolatility", _wrap_GeneralizedBlackScholesProcess_blackVolatility, METH_O, NULL},
	 { "delete_GeneralizedBlackScholesProcess", _wrap_delete_GeneralizedBlackScholesProcess, METH_O, NULL},
	 { "GeneralizedBlackScholesProcess_swigregister", GeneralizedBlackScholesProcess_swigregister, METH_O, NULL},
	 { "GeneralizedBlackScholesProcess_swiginit", GeneralizedBlackScholesProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BlackScholesProcess", _wrap_new_BlackScholesProcess, METH_VARARGS, NULL},
	 { "delete_BlackScholesProcess", _wrap_delete_BlackScholesProcess, METH_O, NULL},
	 { "BlackScholesProcess_swigregister", BlackScholesProcess_swigregister, METH_O, NULL},
	 { "BlackScholesProcess_swiginit", BlackScholesProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BlackScholesMertonProcess", _wrap_new_BlackScholesMertonProcess, METH_VARARGS, NULL},
	 { "delete_BlackScholesMertonProcess", _wrap_delete_BlackScholesMertonProcess, METH_O, NULL},
	 { "BlackScholesMertonProcess_swigregister", BlackScholesMertonProcess_swigregister, METH_O, NULL},
	 { "BlackScholesMertonProcess_swiginit", BlackScholesMertonProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BlackProcess", _wrap_new_BlackProcess, METH_VARARGS, NULL},
	 { "delete_BlackProcess", _wrap_delete_BlackProcess, METH_O, NULL},
	 { "BlackProcess_swigregister", BlackProcess_swigregister, METH_O, NULL},
	 { "BlackProcess_swiginit", BlackProcess_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKohlagenProcess", _wrap_new_GarmanKohlagenProcess, METH_VARARGS, NULL},
	 { "delete_GarmanKohlagenProcess", _wrap_delete_GarmanKohlagenProcess, METH_O, NULL},
	 { "GarmanKohlagenProcess_swigregister", GarmanKohlagenProcess_swigregister, METH_O, NULL},
	 { "GarmanKohlagenProcess_swiginit", GarmanKohlagenProcess_swiginit, METH_VARARGS, NULL},
	 { "new_Merton76Process", _wrap_new_Merton76Process, METH_VARARGS, NULL},
	 { "delete_Merton76Process", _wrap_delete_Merton76Process, METH_O, NULL},
	 { "Merton76Process_swigregister", Merton76Process_swigregister, METH_O, NULL},
	 { "Merton76Process_swiginit", Merton76Process_swiginit, METH_VARARGS, NULL},
	 { "new_StochasticProcessArray", _wrap_new_StochasticProcessArray, METH_VARARGS, NULL},
	 { "delete_StochasticProcessArray", _wrap_delete_StochasticProcessArray, METH_O, NULL},
	 { "StochasticProcessArray_swigregister", StochasticProcessArray_swigregister, METH_O, NULL},
	 { "StochasticProcessArray_swiginit", StochasticProcessArray_swiginit, METH_VARARGS, NULL},
	 { "new_GeometricBrownianMotionProcess", _wrap_new_GeometricBrownianMotionProcess, METH_VARARGS, NULL},
	 { "delete_GeometricBrownianMotionProcess", _wrap_delete_GeometricBrownianMotionProcess, METH_O, NULL},
	 { "GeometricBrownianMotionProcess_swigregister", GeometricBrownianMotionProcess_swigregister, METH_O, NULL},
	 { "GeometricBrownianMotionProcess_swiginit", GeometricBrownianMotionProcess_swiginit, METH_VARARGS, NULL},
	 { "new_VarianceGammaProcess", _wrap_new_VarianceGammaProcess, METH_VARARGS, NULL},
	 { "delete_VarianceGammaProcess", _wrap_delete_VarianceGammaProcess, METH_O, NULL},
	 { "VarianceGammaProcess_swigregister", VarianceGammaProcess_swigregister, METH_O, NULL},
	 { "VarianceGammaProcess_swiginit", VarianceGammaProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HestonProcess", _wrap_new_HestonProcess, METH_VARARGS, NULL},
	 { "HestonProcess_s0", _wrap_HestonProcess_s0, METH_O, NULL},
	 { "HestonProcess_dividendYield", _wrap_HestonProcess_dividendYield, METH_O, NULL},
	 { "HestonProcess_riskFreeRate", _wrap_HestonProcess_riskFreeRate, METH_O, NULL},
	 { "delete_HestonProcess", _wrap_delete_HestonProcess, METH_O, NULL},
	 { "HestonProcess_swigregister", HestonProcess_swigregister, METH_O, NULL},
	 { "HestonProcess_swiginit", HestonProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BatesProcess", _wrap_new_BatesProcess, METH_VARARGS, NULL},
	 { "delete_BatesProcess", _wrap_delete_BatesProcess, METH_O, NULL},
	 { "BatesProcess_swigregister", BatesProcess_swigregister, METH_O, NULL},
	 { "BatesProcess_swiginit", BatesProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HullWhiteProcess", _wrap_new_HullWhiteProcess, METH_VARARGS, NULL},
	 { "delete_HullWhiteProcess", _wrap_delete_HullWhiteProcess, METH_O, NULL},
	 { "HullWhiteProcess_swigregister", HullWhiteProcess_swigregister, METH_O, NULL},
	 { "HullWhiteProcess_swiginit", HullWhiteProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HullWhiteForwardProcess", _wrap_new_HullWhiteForwardProcess, METH_VARARGS, NULL},
	 { "HullWhiteForwardProcess_alpha", _wrap_HullWhiteForwardProcess_alpha, METH_VARARGS, NULL},
	 { "HullWhiteForwardProcess_M_T", _wrap_HullWhiteForwardProcess_M_T, METH_VARARGS, NULL},
	 { "HullWhiteForwardProcess_B", _wrap_HullWhiteForwardProcess_B, METH_VARARGS, NULL},
	 { "HullWhiteForwardProcess_setForwardMeasureTime", _wrap_HullWhiteForwardProcess_setForwardMeasureTime, METH_VARARGS, NULL},
	 { "delete_HullWhiteForwardProcess", _wrap_delete_HullWhiteForwardProcess, METH_O, NULL},
	 { "HullWhiteForwardProcess_swigregister", HullWhiteForwardProcess_swigregister, METH_O, NULL},
	 { "HullWhiteForwardProcess_swiginit", HullWhiteForwardProcess_swiginit, METH_VARARGS, NULL},
	 { "new_G2Process", _wrap_new_G2Process, METH_VARARGS, NULL},
	 { "delete_G2Process", _wrap_delete_G2Process, METH_O, NULL},
	 { "G2Process_swigregister", G2Process_swigregister, METH_O, NULL},
	 { "G2Process_swiginit", G2Process_swiginit, METH_VARARGS, NULL},
	 { "new_G2ForwardProcess", _wrap_new_G2ForwardProcess, METH_VARARGS, NULL},
	 { "G2ForwardProcess_setForwardMeasureTime", _wrap_G2ForwardProcess_setForwardMeasureTime, METH_VARARGS, NULL},
	 { "delete_G2ForwardProcess", _wrap_delete_G2ForwardProcess, METH_O, NULL},
	 { "G2ForwardProcess_swigregister", G2ForwardProcess_swigregister, METH_O, NULL},
	 { "G2ForwardProcess_swiginit", G2ForwardProcess_swiginit, METH_VARARGS, NULL},
	 { "new_GsrProcess", _wrap_new_GsrProcess, METH_VARARGS, NULL},
	 { "GsrProcess_sigma", _wrap_GsrProcess_sigma, METH_VARARGS, NULL},
	 { "GsrProcess_reversion", _wrap_GsrProcess_reversion, METH_VARARGS, NULL},
	 { "GsrProcess_y", _wrap_GsrProcess_y, METH_VARARGS, NULL},
	 { "GsrProcess_G", _wrap_GsrProcess_G, METH_VARARGS, NULL},
	 { "GsrProcess_setForwardMeasureTime", _wrap_GsrProcess_setForwardMeasureTime, METH_VARARGS, NULL},
	 { "delete_GsrProcess", _wrap_delete_GsrProcess, METH_O, NULL},
	 { "GsrProcess_swigregister", GsrProcess_swigregister, METH_O, NULL},
	 { "GsrProcess_swiginit", GsrProcess_swiginit, METH_VARARGS, NULL},
	 { "as_gsr_process", _wrap_as_gsr_process, METH_O, NULL},
	 { "new_OrnsteinUhlenbeckProcess", _wrap_new_OrnsteinUhlenbeckProcess, METH_VARARGS, NULL},
	 { "OrnsteinUhlenbeckProcess_speed", _wrap_OrnsteinUhlenbeckProcess_speed, METH_O, NULL},
	 { "OrnsteinUhlenbeckProcess_volatility", _wrap_OrnsteinUhlenbeckProcess_volatility, METH_O, NULL},
	 { "OrnsteinUhlenbeckProcess_level", _wrap_OrnsteinUhlenbeckProcess_level, METH_O, NULL},
	 { "delete_OrnsteinUhlenbeckProcess", _wrap_delete_OrnsteinUhlenbeckProcess, METH_O, NULL},
	 { "OrnsteinUhlenbeckProcess_swigregister", OrnsteinUhlenbeckProcess_swigregister, METH_O, NULL},
	 { "OrnsteinUhlenbeckProcess_swiginit", OrnsteinUhlenbeckProcess_swiginit, METH_VARARGS, NULL},
	 { "new_ExtendedOrnsteinUhlenbeckProcess", _wrap_new_ExtendedOrnsteinUhlenbeckProcess, METH_VARARGS, NULL},
	 { "delete_ExtendedOrnsteinUhlenbeckProcess", _wrap_delete_ExtendedOrnsteinUhlenbeckProcess, METH_O, NULL},
	 { "ExtendedOrnsteinUhlenbeckProcess_swigregister", ExtendedOrnsteinUhlenbeckProcess_swigregister, METH_O, NULL},
	 { "ExtendedOrnsteinUhlenbeckProcess_swiginit", ExtendedOrnsteinUhlenbeckProcess_swiginit, METH_VARARGS, NULL},
	 { "new_ExtOUWithJumpsProcess", _wrap_new_ExtOUWithJumpsProcess, METH_VARARGS, NULL},
	 { "delete_ExtOUWithJumpsProcess", _wrap_delete_ExtOUWithJumpsProcess, METH_O, NULL},
	 { "ExtOUWithJumpsProcess_swigregister", ExtOUWithJumpsProcess_swigregister, METH_O, NULL},
	 { "ExtOUWithJumpsProcess_swiginit", ExtOUWithJumpsProcess_swiginit, METH_VARARGS, NULL},
	 { "new_KlugeExtOUProcess", _wrap_new_KlugeExtOUProcess, METH_VARARGS, NULL},
	 { "delete_KlugeExtOUProcess", _wrap_delete_KlugeExtOUProcess, METH_O, NULL},
	 { "KlugeExtOUProcess_swigregister", KlugeExtOUProcess_swigregister, METH_O, NULL},
	 { "KlugeExtOUProcess_swiginit", KlugeExtOUProcess_swiginit, METH_VARARGS, NULL},
	 { "new_GJRGARCHProcess", _wrap_new_GJRGARCHProcess, METH_VARARGS, NULL},
	 { "GJRGARCHProcess_s0", _wrap_GJRGARCHProcess_s0, METH_O, NULL},
	 { "GJRGARCHProcess_dividendYield", _wrap_GJRGARCHProcess_dividendYield, METH_O, NULL},
	 { "GJRGARCHProcess_riskFreeRate", _wrap_GJRGARCHProcess_riskFreeRate, METH_O, NULL},
	 { "delete_GJRGARCHProcess", _wrap_delete_GJRGARCHProcess, METH_O, NULL},
	 { "GJRGARCHProcess_swigregister", GJRGARCHProcess_swigregister, METH_O, NULL},
	 { "GJRGARCHProcess_swiginit", GJRGARCHProcess_swiginit, METH_VARARGS, NULL},
	 { "delete_PricingEngine", _wrap_delete_PricingEngine, METH_O, NULL},
	 { "PricingEngine_swigregister", PricingEngine_swigregister, METH_O, NULL},
	 { "Instrument_NPV", _wrap_Instrument_NPV, METH_O, NULL},
	 { "Instrument_errorEstimate", _wrap_Instrument_errorEstimate, METH_O, NULL},
	 { "Instrument_isExpired", _wrap_Instrument_isExpired, METH_O, NULL},
	 { "Instrument_setPricingEngine", _wrap_Instrument_setPricingEngine, METH_VARARGS, NULL},
	 { "Instrument_recalculate", _wrap_Instrument_recalculate, METH_O, NULL},
	 { "Instrument_freeze", _wrap_Instrument_freeze, METH_O, NULL},
	 { "Instrument_unfreeze", _wrap_Instrument_unfreeze, METH_O, NULL},
	 { "delete_Instrument", _wrap_delete_Instrument, METH_O, NULL},
	 { "Instrument_swigregister", Instrument_swigregister, METH_O, NULL},
	 { "InstrumentVector_iterator", _wrap_InstrumentVector_iterator, METH_O, NULL},
	 { "InstrumentVector___nonzero__", _wrap_InstrumentVector___nonzero__, METH_O, NULL},
	 { "InstrumentVector___bool__", _wrap_InstrumentVector___bool__, METH_O, NULL},
	 { "InstrumentVector___len__", _wrap_InstrumentVector___len__, METH_O, NULL},
	 { "InstrumentVector___getslice__", _wrap_InstrumentVector___getslice__, METH_VARARGS, NULL},
	 { "InstrumentVector___setslice__", _wrap_InstrumentVector___setslice__, METH_VARARGS, NULL},
	 { "InstrumentVector___delslice__", _wrap_InstrumentVector___delslice__, METH_VARARGS, NULL},
	 { "InstrumentVector___delitem__", _wrap_InstrumentVector___delitem__, METH_VARARGS, NULL},
	 { "InstrumentVector___getitem__", _wrap_InstrumentVector___getitem__, METH_VARARGS, NULL},
	 { "InstrumentVector___setitem__", _wrap_InstrumentVector___setitem__, METH_VARARGS, NULL},
	 { "InstrumentVector_pop", _wrap_InstrumentVector_pop, METH_O, NULL},
	 { "InstrumentVector_append", _wrap_InstrumentVector_append, METH_VARARGS, NULL},
	 { "InstrumentVector_empty", _wrap_InstrumentVector_empty, METH_O, NULL},
	 { "InstrumentVector_size", _wrap_InstrumentVector_size, METH_O, NULL},
	 { "InstrumentVector_swap", _wrap_InstrumentVector_swap, METH_VARARGS, NULL},
	 { "InstrumentVector_begin", _wrap_InstrumentVector_begin, METH_O, NULL},
	 { "InstrumentVector_end", _wrap_InstrumentVector_end, METH_O, NULL},
	 { "InstrumentVector_rbegin", _wrap_InstrumentVector_rbegin, METH_O, NULL},
	 { "InstrumentVector_rend", _wrap_InstrumentVector_rend, METH_O, NULL},
	 { "InstrumentVector_clear", _wrap_InstrumentVector_clear, METH_O, NULL},
	 { "InstrumentVector_get_allocator", _wrap_InstrumentVector_get_allocator, METH_O, NULL},
	 { "InstrumentVector_pop_back", _wrap_InstrumentVector_pop_back, METH_O, NULL},
	 { "InstrumentVector_erase", _wrap_InstrumentVector_erase, METH_VARARGS, NULL},
	 { "new_InstrumentVector", _wrap_new_InstrumentVector, METH_VARARGS, NULL},
	 { "InstrumentVector_push_back", _wrap_InstrumentVector_push_back, METH_VARARGS, NULL},
	 { "InstrumentVector_front", _wrap_InstrumentVector_front, METH_O, NULL},
	 { "InstrumentVector_back", _wrap_InstrumentVector_back, METH_O, NULL},
	 { "InstrumentVector_assign", _wrap_InstrumentVector_assign, METH_VARARGS, NULL},
	 { "InstrumentVector_resize", _wrap_InstrumentVector_resize, METH_VARARGS, NULL},
	 { "InstrumentVector_insert", _wrap_InstrumentVector_insert, METH_VARARGS, NULL},
	 { "InstrumentVector_reserve", _wrap_InstrumentVector_reserve, METH_VARARGS, NULL},
	 { "InstrumentVector_capacity", _wrap_InstrumentVector_capacity, METH_O, NULL},
	 { "delete_InstrumentVector", _wrap_delete_InstrumentVector, METH_O, NULL},
	 { "InstrumentVector_swigregister", InstrumentVector_swigregister, METH_O, NULL},
	 { "InstrumentVector_swiginit", InstrumentVector_swiginit, METH_VARARGS, NULL},
	 { "new_Stock", _wrap_new_Stock, METH_O, NULL},
	 { "delete_Stock", _wrap_delete_Stock, METH_O, NULL},
	 { "Stock_swigregister", Stock_swigregister, METH_O, NULL},
	 { "Stock_swiginit", Stock_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeInstrument", _wrap_new_CompositeInstrument, METH_NOARGS, NULL},
	 { "CompositeInstrument_add", _wrap_CompositeInstrument_add, METH_VARARGS, NULL},
	 { "CompositeInstrument_subtract", _wrap_CompositeInstrument_subtract, METH_VARARGS, NULL},
	 { "delete_CompositeInstrument", _wrap_delete_CompositeInstrument, METH_O, NULL},
	 { "CompositeInstrument_swigregister", CompositeInstrument_swigregister, METH_O, NULL},
	 { "CompositeInstrument_swiginit", CompositeInstrument_swiginit, METH_VARARGS, NULL},
	 { "new_DateGeneration", _wrap_new_DateGeneration, METH_NOARGS, NULL},
	 { "delete_DateGeneration", _wrap_delete_DateGeneration, METH_O, NULL},
	 { "DateGeneration_swigregister", DateGeneration_swigregister, METH_O, NULL},
	 { "DateGeneration_swiginit", DateGeneration_swiginit, METH_VARARGS, NULL},
	 { "new_Schedule", _wrap_new_Schedule, METH_VARARGS, NULL},
	 { "Schedule___len__", _wrap_Schedule___len__, METH_O, NULL},
	 { "Schedule_previousDate", _wrap_Schedule_previousDate, METH_VARARGS, NULL},
	 { "Schedule_nextDate", _wrap_Schedule_nextDate, METH_VARARGS, NULL},
	 { "Schedule_hasIsRegular", _wrap_Schedule_hasIsRegular, METH_O, NULL},
	 { "Schedule_isRegular", _wrap_Schedule_isRegular, METH_VARARGS, NULL},
	 { "Schedule_calendar", _wrap_Schedule_calendar, METH_O, NULL},
	 { "Schedule_startDate", _wrap_Schedule_startDate, METH_O, NULL},
	 { "Schedule_endDate", _wrap_Schedule_endDate, METH_O, NULL},
	 { "Schedule_hasTenor", _wrap_Schedule_hasTenor, METH_O, NULL},
	 { "Schedule_tenor", _wrap_Schedule_tenor, METH_O, NULL},
	 { "Schedule_businessDayConvention", _wrap_Schedule_businessDayConvention, METH_O, NULL},
	 { "Schedule_hasTerminationDateBusinessDayConvention", _wrap_Schedule_hasTerminationDateBusinessDayConvention, METH_O, NULL},
	 { "Schedule_terminationDateBusinessDayConvention", _wrap_Schedule_terminationDateBusinessDayConvention, METH_O, NULL},
	 { "Schedule_hasRule", _wrap_Schedule_hasRule, METH_O, NULL},
	 { "Schedule_rule", _wrap_Schedule_rule, METH_O, NULL},
	 { "Schedule_hasEndOfMonth", _wrap_Schedule_hasEndOfMonth, METH_O, NULL},
	 { "Schedule_endOfMonth", _wrap_Schedule_endOfMonth, METH_O, NULL},
	 { "Schedule_until", _wrap_Schedule_until, METH_VARARGS, NULL},
	 { "Schedule___getitem__", _wrap_Schedule___getitem__, METH_VARARGS, NULL},
	 { "delete_Schedule", _wrap_delete_Schedule, METH_O, NULL},
	 { "Schedule_swigregister", Schedule_swigregister, METH_O, NULL},
	 { "Schedule_swiginit", Schedule_swiginit, METH_VARARGS, NULL},
	 { "new__MakeSchedule", _wrap_new__MakeSchedule, METH_NOARGS, NULL},
	 { "_MakeSchedule_fromDate", _wrap__MakeSchedule_fromDate, METH_VARARGS, NULL},
	 { "_MakeSchedule_to", _wrap__MakeSchedule_to, METH_VARARGS, NULL},
	 { "_MakeSchedule_withTenor", _wrap__MakeSchedule_withTenor, METH_VARARGS, NULL},
	 { "_MakeSchedule_withFrequency", _wrap__MakeSchedule_withFrequency, METH_VARARGS, NULL},
	 { "_MakeSchedule_withCalendar", _wrap__MakeSchedule_withCalendar, METH_VARARGS, NULL},
	 { "_MakeSchedule_withConvention", _wrap__MakeSchedule_withConvention, METH_VARARGS, NULL},
	 { "_MakeSchedule_withTerminationDateConvention", _wrap__MakeSchedule_withTerminationDateConvention, METH_VARARGS, NULL},
	 { "_MakeSchedule_withRule", _wrap__MakeSchedule_withRule, METH_VARARGS, NULL},
	 { "_MakeSchedule_forwards", _wrap__MakeSchedule_forwards, METH_O, NULL},
	 { "_MakeSchedule_backwards", _wrap__MakeSchedule_backwards, METH_O, NULL},
	 { "_MakeSchedule_endOfMonth", _wrap__MakeSchedule_endOfMonth, METH_VARARGS, NULL},
	 { "_MakeSchedule_withFirstDate", _wrap__MakeSchedule_withFirstDate, METH_VARARGS, NULL},
	 { "_MakeSchedule_withNextToLastDate", _wrap__MakeSchedule_withNextToLastDate, METH_VARARGS, NULL},
	 { "_MakeSchedule_schedule", _wrap__MakeSchedule_schedule, METH_O, NULL},
	 { "delete__MakeSchedule", _wrap_delete__MakeSchedule, METH_O, NULL},
	 { "_MakeSchedule_swigregister", _MakeSchedule_swigregister, METH_O, NULL},
	 { "_MakeSchedule_swiginit", _MakeSchedule_swiginit, METH_VARARGS, NULL},
	 { "CashFlow_amount", _wrap_CashFlow_amount, METH_O, NULL},
	 { "CashFlow_date", _wrap_CashFlow_date, METH_O, NULL},
	 { "CashFlow_hasOccurred", _wrap_CashFlow_hasOccurred, METH_VARARGS, NULL},
	 { "delete_CashFlow", _wrap_delete_CashFlow, METH_O, NULL},
	 { "CashFlow_swigregister", CashFlow_swigregister, METH_O, NULL},
	 { "Leg_iterator", _wrap_Leg_iterator, METH_O, NULL},
	 { "Leg___nonzero__", _wrap_Leg___nonzero__, METH_O, NULL},
	 { "Leg___bool__", _wrap_Leg___bool__, METH_O, NULL},
	 { "Leg___len__", _wrap_Leg___len__, METH_O, NULL},
	 { "Leg___getslice__", _wrap_Leg___getslice__, METH_VARARGS, NULL},
	 { "Leg___setslice__", _wrap_Leg___setslice__, METH_VARARGS, NULL},
	 { "Leg___delslice__", _wrap_Leg___delslice__, METH_VARARGS, NULL},
	 { "Leg___delitem__", _wrap_Leg___delitem__, METH_VARARGS, NULL},
	 { "Leg___getitem__", _wrap_Leg___getitem__, METH_VARARGS, NULL},
	 { "Leg___setitem__", _wrap_Leg___setitem__, METH_VARARGS, NULL},
	 { "Leg_pop", _wrap_Leg_pop, METH_O, NULL},
	 { "Leg_append", _wrap_Leg_append, METH_VARARGS, NULL},
	 { "Leg_empty", _wrap_Leg_empty, METH_O, NULL},
	 { "Leg_size", _wrap_Leg_size, METH_O, NULL},
	 { "Leg_swap", _wrap_Leg_swap, METH_VARARGS, NULL},
	 { "Leg_begin", _wrap_Leg_begin, METH_O, NULL},
	 { "Leg_end", _wrap_Leg_end, METH_O, NULL},
	 { "Leg_rbegin", _wrap_Leg_rbegin, METH_O, NULL},
	 { "Leg_rend", _wrap_Leg_rend, METH_O, NULL},
	 { "Leg_clear", _wrap_Leg_clear, METH_O, NULL},
	 { "Leg_get_allocator", _wrap_Leg_get_allocator, METH_O, NULL},
	 { "Leg_pop_back", _wrap_Leg_pop_back, METH_O, NULL},
	 { "Leg_erase", _wrap_Leg_erase, METH_VARARGS, NULL},
	 { "new_Leg", _wrap_new_Leg, METH_VARARGS, NULL},
	 { "Leg_push_back", _wrap_Leg_push_back, METH_VARARGS, NULL},
	 { "Leg_front", _wrap_Leg_front, METH_O, NULL},
	 { "Leg_back", _wrap_Leg_back, METH_O, NULL},
	 { "Leg_assign", _wrap_Leg_assign, METH_VARARGS, NULL},
	 { "Leg_resize", _wrap_Leg_resize, METH_VARARGS, NULL},
	 { "Leg_insert", _wrap_Leg_insert, METH_VARARGS, NULL},
	 { "Leg_reserve", _wrap_Leg_reserve, METH_VARARGS, NULL},
	 { "Leg_capacity", _wrap_Leg_capacity, METH_O, NULL},
	 { "delete_Leg", _wrap_delete_Leg, METH_O, NULL},
	 { "Leg_swigregister", Leg_swigregister, METH_O, NULL},
	 { "Leg_swiginit", Leg_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleCashFlow", _wrap_new_SimpleCashFlow, METH_VARARGS, NULL},
	 { "delete_SimpleCashFlow", _wrap_delete_SimpleCashFlow, METH_O, NULL},
	 { "SimpleCashFlow_swigregister", SimpleCashFlow_swigregister, METH_O, NULL},
	 { "SimpleCashFlow_swiginit", SimpleCashFlow_swiginit, METH_VARARGS, NULL},
	 { "new_Redemption", _wrap_new_Redemption, METH_VARARGS, NULL},
	 { "delete_Redemption", _wrap_delete_Redemption, METH_O, NULL},
	 { "Redemption_swigregister", Redemption_swigregister, METH_O, NULL},
	 { "Redemption_swiginit", Redemption_swiginit, METH_VARARGS, NULL},
	 { "new_AmortizingPayment", _wrap_new_AmortizingPayment, METH_VARARGS, NULL},
	 { "delete_AmortizingPayment", _wrap_delete_AmortizingPayment, METH_O, NULL},
	 { "AmortizingPayment_swigregister", AmortizingPayment_swigregister, METH_O, NULL},
	 { "AmortizingPayment_swiginit", AmortizingPayment_swiginit, METH_VARARGS, NULL},
	 { "new_IndexedCashFlow", _wrap_new_IndexedCashFlow, METH_VARARGS, NULL},
	 { "IndexedCashFlow_notional", _wrap_IndexedCashFlow_notional, METH_O, NULL},
	 { "IndexedCashFlow_baseDate", _wrap_IndexedCashFlow_baseDate, METH_O, NULL},
	 { "IndexedCashFlow_fixingDate", _wrap_IndexedCashFlow_fixingDate, METH_O, NULL},
	 { "IndexedCashFlow_index", _wrap_IndexedCashFlow_index, METH_O, NULL},
	 { "IndexedCashFlow_growthOnly", _wrap_IndexedCashFlow_growthOnly, METH_O, NULL},
	 { "delete_IndexedCashFlow", _wrap_delete_IndexedCashFlow, METH_O, NULL},
	 { "IndexedCashFlow_swigregister", IndexedCashFlow_swigregister, METH_O, NULL},
	 { "IndexedCashFlow_swiginit", IndexedCashFlow_swiginit, METH_VARARGS, NULL},
	 { "as_indexed_cashflow", _wrap_as_indexed_cashflow, METH_O, NULL},
	 { "Coupon_nominal", _wrap_Coupon_nominal, METH_O, NULL},
	 { "Coupon_accrualStartDate", _wrap_Coupon_accrualStartDate, METH_O, NULL},
	 { "Coupon_accrualEndDate", _wrap_Coupon_accrualEndDate, METH_O, NULL},
	 { "Coupon_referencePeriodStart", _wrap_Coupon_referencePeriodStart, METH_O, NULL},
	 { "Coupon_referencePeriodEnd", _wrap_Coupon_referencePeriodEnd, METH_O, NULL},
	 { "Coupon_exCouponDate", _wrap_Coupon_exCouponDate, METH_O, NULL},
	 { "Coupon_rate", _wrap_Coupon_rate, METH_O, NULL},
	 { "Coupon_accrualPeriod", _wrap_Coupon_accrualPeriod, METH_O, NULL},
	 { "Coupon_accrualDays", _wrap_Coupon_accrualDays, METH_O, NULL},
	 { "Coupon_dayCounter", _wrap_Coupon_dayCounter, METH_O, NULL},
	 { "Coupon_accruedAmount", _wrap_Coupon_accruedAmount, METH_VARARGS, NULL},
	 { "delete_Coupon", _wrap_delete_Coupon, METH_O, NULL},
	 { "Coupon_swigregister", Coupon_swigregister, METH_O, NULL},
	 { "as_coupon", _wrap_as_coupon, METH_O, NULL},
	 { "new_FixedRateCoupon", (PyCFunction)(void(*)(void))_wrap_new_FixedRateCoupon, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "FixedRateCoupon_interestRate", _wrap_FixedRateCoupon_interestRate, METH_O, NULL},
	 { "delete_FixedRateCoupon", _wrap_delete_FixedRateCoupon, METH_O, NULL},
	 { "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, NULL},
	 { "FloatingRateCouponPricer_swapletPrice", _wrap_FloatingRateCouponPricer_swapletPrice, METH_O, NULL},
	 { "FloatingRateCouponPricer_swapletRate", _wrap_FloatingRateCouponPricer_swapletRate, METH_O, NULL},
	 { "FloatingRateCouponPricer_capletPrice", _wrap_FloatingRateCouponPricer_capletPrice, METH_VARARGS, NULL},
	 { "FloatingRateCouponPricer_capletRate", _wrap_FloatingRateCouponPricer_capletRate, METH_VARARGS, NULL},
	 { "FloatingRateCouponPricer_floorletPrice", _wrap_FloatingRateCouponPricer_floorletPrice, METH_VARARGS, NULL},
	 { "FloatingRateCouponPricer_floorletRate", _wrap_FloatingRateCouponPricer_floorletRate, METH_VARARGS, NULL},
	 { "delete_FloatingRateCouponPricer", _wrap_delete_FloatingRateCouponPricer, METH_O, NULL},
	 { "FloatingRateCouponPricer_swigregister", FloatingRateCouponPricer_swigregister, METH_O, NULL},
	 { "setCouponPricer", _wrap_setCouponPricer, METH_VARARGS, NULL},
	 { "FloatingRateCoupon_fixingDate", _wrap_FloatingRateCoupon_fixingDate, METH_O, NULL},
	 { "FloatingRateCoupon_fixingDays", _wrap_FloatingRateCoupon_fixingDays, METH_O, NULL},
	 { "FloatingRateCoupon_isInArrears", _wrap_FloatingRateCoupon_isInArrears, METH_O, NULL},
	 { "FloatingRateCoupon_gearing", _wrap_FloatingRateCoupon_gearing, METH_O, NULL},
	 { "FloatingRateCoupon_spread", _wrap_FloatingRateCoupon_spread, METH_O, NULL},
	 { "FloatingRateCoupon_indexFixing", _wrap_FloatingRateCoupon_indexFixing, METH_O, NULL},
	 { "FloatingRateCoupon_adjustedFixing", _wrap_FloatingRateCoupon_adjustedFixing, METH_O, NULL},
	 { "FloatingRateCoupon_convexityAdjustment", _wrap_FloatingRateCoupon_convexityAdjustment, METH_O, NULL},
	 { "FloatingRateCoupon_price", _wrap_FloatingRateCoupon_price, METH_VARARGS, NULL},
	 { "FloatingRateCoupon_index", _wrap_FloatingRateCoupon_index, METH_O, NULL},
	 { "FloatingRateCoupon_setPricer", _wrap_FloatingRateCoupon_setPricer, METH_VARARGS, NULL},
	 { "delete_FloatingRateCoupon", _wrap_delete_FloatingRateCoupon, METH_O, NULL},
	 { "FloatingRateCoupon_swigregister", FloatingRateCoupon_swigregister, METH_O, NULL},
	 { "as_floating_rate_coupon", _wrap_as_floating_rate_coupon, METH_O, NULL},
	 { "new_OvernightIndexedCoupon", _wrap_new_OvernightIndexedCoupon, METH_VARARGS, NULL},
	 { "OvernightIndexedCoupon_fixingDates", _wrap_OvernightIndexedCoupon_fixingDates, METH_O, NULL},
	 { "OvernightIndexedCoupon_dt", _wrap_OvernightIndexedCoupon_dt, METH_O, NULL},
	 { "OvernightIndexedCoupon_indexFixings", _wrap_OvernightIndexedCoupon_indexFixings, METH_O, NULL},
	 { "OvernightIndexedCoupon_valueDates", _wrap_OvernightIndexedCoupon_valueDates, METH_O, NULL},
	 { "delete_OvernightIndexedCoupon", _wrap_delete_OvernightIndexedCoupon, METH_O, NULL},
	 { "OvernightIndexedCoupon_swigregister", OvernightIndexedCoupon_swigregister, METH_O, NULL},
	 { "OvernightIndexedCoupon_swiginit", OvernightIndexedCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_CappedFlooredCoupon", (PyCFunction)(void(*)(void))_wrap_new_CappedFlooredCoupon, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CappedFlooredCoupon_cap", _wrap_CappedFlooredCoupon_cap, METH_O, NULL},
	 { "CappedFlooredCoupon_floor", _wrap_CappedFlooredCoupon_floor, METH_O, NULL},
	 { "CappedFlooredCoupon_effectiveCap", _wrap_CappedFlooredCoupon_effectiveCap, METH_O, NULL},
	 { "CappedFlooredCoupon_effectiveFloor", _wrap_CappedFlooredCoupon_effectiveFloor, METH_O, NULL},
	 { "CappedFlooredCoupon_isCapped", _wrap_CappedFlooredCoupon_isCapped, METH_O, NULL},
	 { "CappedFlooredCoupon_isFloored", _wrap_CappedFlooredCoupon_isFloored, METH_O, NULL},
	 { "CappedFlooredCoupon_setPricer", _wrap_CappedFlooredCoupon_setPricer, METH_VARARGS, NULL},
	 { "delete_CappedFlooredCoupon", _wrap_delete_CappedFlooredCoupon, METH_O, NULL},
	 { "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, NULL},
	 { "IborCoupon_createAtParCoupons", _wrap_IborCoupon_createAtParCoupons, METH_NOARGS, NULL},
	 { "IborCoupon_createIndexedCoupons", _wrap_IborCoupon_createIndexedCoupons, METH_NOARGS, NULL},
	 { "IborCoupon_usingAtParCoupons", _wrap_IborCoupon_usingAtParCoupons, METH_NOARGS, NULL},
	 { "delete_IborCoupon", _wrap_delete_IborCoupon, METH_O, NULL},
	 { "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, NULL},
	 { "delete_CappedFlooredIborCoupon", _wrap_delete_CappedFlooredIborCoupon, METH_O, NULL},
	 { "CappedFlooredIborCoupon_swigregister", CappedFlooredIborCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredIborCoupon_swiginit", CappedFlooredIborCoupon_swiginit, METH_VARARGS, NULL},
	 { "IborCouponPricer_capletVolatility", _wrap_IborCouponPricer_capletVolatility, METH_O, NULL},
	 { "IborCouponPricer_setCapletVolatility", _wrap_IborCouponPricer_setCapletVolatility, METH_VARARGS, NULL},
	 { "delete_IborCouponPricer", _wrap_delete_IborCouponPricer, METH_O, NULL},
	 { "IborCouponPricer_swigregister", IborCouponPricer_swigregister, METH_O, NULL},
	 { "new_BlackIborCouponPricer", _wrap_new_BlackIborCouponPricer, METH_VARARGS, NULL},
	 { "delete_BlackIborCouponPricer", _wrap_delete_BlackIborCouponPricer, METH_O, NULL},
	 { "BlackIborCouponPricer_swigregister", BlackIborCouponPricer_swigregister, METH_O, NULL},
	 { "BlackIborCouponPricer_swiginit", BlackIborCouponPricer_swiginit, METH_VARARGS, NULL},
	 { "new_CmsCoupon", (PyCFunction)(void(*)(void))_wrap_new_CmsCoupon, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_CmsCoupon", _wrap_delete_CmsCoupon, METH_O, NULL},
	 { "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, NULL},
	 { "delete_CmsSpreadCoupon", _wrap_delete_CmsSpreadCoupon, METH_O, NULL},
	 { "CmsSpreadCoupon_swigregister", CmsSpreadCoupon_swigregister, METH_O, NULL},
	 { "CmsSpreadCoupon_swiginit", CmsSpreadCoupon_swiginit, METH_VARARGS, NULL},
	 { "CmsCouponPricer_swaptionVolatility", _wrap_CmsCouponPricer_swaptionVolatility, METH_O, NULL},
	 { "CmsCouponPricer_setSwaptionVolatility", _wrap_CmsCouponPricer_setSwaptionVolatility, METH_VARARGS, NULL},
	 { "delete_CmsCouponPricer", _wrap_delete_CmsCouponPricer, METH_O, NULL},
	 { "CmsCouponPricer_swigregister", CmsCouponPricer_swigregister, METH_O, NULL},
	 { "CmsCouponPricerVector_iterator", _wrap_CmsCouponPricerVector_iterator, METH_O, NULL},
	 { "CmsCouponPricerVector___nonzero__", _wrap_CmsCouponPricerVector___nonzero__, METH_O, NULL},
	 { "CmsCouponPricerVector___bool__", _wrap_CmsCouponPricerVector___bool__, METH_O, NULL},
	 { "CmsCouponPricerVector___len__", _wrap_CmsCouponPricerVector___len__, METH_O, NULL},
	 { "CmsCouponPricerVector___getslice__", _wrap_CmsCouponPricerVector___getslice__, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector___setslice__", _wrap_CmsCouponPricerVector___setslice__, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector___delslice__", _wrap_CmsCouponPricerVector___delslice__, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector___delitem__", _wrap_CmsCouponPricerVector___delitem__, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector___getitem__", _wrap_CmsCouponPricerVector___getitem__, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector___setitem__", _wrap_CmsCouponPricerVector___setitem__, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_pop", _wrap_CmsCouponPricerVector_pop, METH_O, NULL},
	 { "CmsCouponPricerVector_append", _wrap_CmsCouponPricerVector_append, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_empty", _wrap_CmsCouponPricerVector_empty, METH_O, NULL},
	 { "CmsCouponPricerVector_size", _wrap_CmsCouponPricerVector_size, METH_O, NULL},
	 { "CmsCouponPricerVector_swap", _wrap_CmsCouponPricerVector_swap, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_begin", _wrap_CmsCouponPricerVector_begin, METH_O, NULL},
	 { "CmsCouponPricerVector_end", _wrap_CmsCouponPricerVector_end, METH_O, NULL},
	 { "CmsCouponPricerVector_rbegin", _wrap_CmsCouponPricerVector_rbegin, METH_O, NULL},
	 { "CmsCouponPricerVector_rend", _wrap_CmsCouponPricerVector_rend, METH_O, NULL},
	 { "CmsCouponPricerVector_clear", _wrap_CmsCouponPricerVector_clear, METH_O, NULL},
	 { "CmsCouponPricerVector_get_allocator", _wrap_CmsCouponPricerVector_get_allocator, METH_O, NULL},
	 { "CmsCouponPricerVector_pop_back", _wrap_CmsCouponPricerVector_pop_back, METH_O, NULL},
	 { "CmsCouponPricerVector_erase", _wrap_CmsCouponPricerVector_erase, METH_VARARGS, NULL},
	 { "new_CmsCouponPricerVector", _wrap_new_CmsCouponPricerVector, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_push_back", _wrap_CmsCouponPricerVector_push_back, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_front", _wrap_CmsCouponPricerVector_front, METH_O, NULL},
	 { "CmsCouponPricerVector_back", _wrap_CmsCouponPricerVector_back, METH_O, NULL},
	 { "CmsCouponPricerVector_assign", _wrap_CmsCouponPricerVector_assign, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_resize", _wrap_CmsCouponPricerVector_resize, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_insert", _wrap_CmsCouponPricerVector_insert, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_reserve", _wrap_CmsCouponPricerVector_reserve, METH_VARARGS, NULL},
	 { "CmsCouponPricerVector_capacity", _wrap_CmsCouponPricerVector_capacity, METH_O, NULL},
	 { "delete_CmsCouponPricerVector", _wrap_delete_CmsCouponPricerVector, METH_O, NULL},
	 { "CmsCouponPricerVector_swigregister", CmsCouponPricerVector_swigregister, METH_O, NULL},
	 { "CmsCouponPricerVector_swiginit", CmsCouponPricerVector_swiginit, METH_VARARGS, NULL},
	 { "delete_GFunctionFactory", _wrap_delete_GFunctionFactory, METH_O, NULL},
	 { "GFunctionFactory_swigregister", GFunctionFactory_swigregister, METH_O, NULL},
	 { "new_AnalyticHaganPricer", _wrap_new_AnalyticHaganPricer, METH_VARARGS, NULL},
	 { "delete_AnalyticHaganPricer", _wrap_delete_AnalyticHaganPricer, METH_O, NULL},
	 { "AnalyticHaganPricer_swigregister", AnalyticHaganPricer_swigregister, METH_O, NULL},
	 { "AnalyticHaganPricer_swiginit", AnalyticHaganPricer_swiginit, METH_VARARGS, NULL},
	 { "new_NumericHaganPricer", _wrap_new_NumericHaganPricer, METH_VARARGS, NULL},
	 { "delete_NumericHaganPricer", _wrap_delete_NumericHaganPricer, METH_O, NULL},
	 { "NumericHaganPricer_swigregister", NumericHaganPricer_swigregister, METH_O, NULL},
	 { "NumericHaganPricer_swiginit", NumericHaganPricer_swiginit, METH_VARARGS, NULL},
	 { "new_CappedFlooredCmsCoupon", _wrap_new_CappedFlooredCmsCoupon, METH_VARARGS, NULL},
	 { "delete_CappedFlooredCmsCoupon", _wrap_delete_CappedFlooredCmsCoupon, METH_O, NULL},
	 { "CappedFlooredCmsCoupon_swigregister", CappedFlooredCmsCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredCmsCoupon_swiginit", CappedFlooredCmsCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_CappedFlooredCmsSpreadCoupon", _wrap_new_CappedFlooredCmsSpreadCoupon, METH_VARARGS, NULL},
	 { "delete_CappedFlooredCmsSpreadCoupon", _wrap_delete_CappedFlooredCmsSpreadCoupon, METH_O, NULL},
	 { "CappedFlooredCmsSpreadCoupon_swigregister", CappedFlooredCmsSpreadCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredCmsSpreadCoupon_swiginit", CappedFlooredCmsSpreadCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_LinearTsrPricer", _wrap_new_LinearTsrPricer, METH_VARARGS, NULL},
	 { "delete_LinearTsrPricer", _wrap_delete_LinearTsrPricer, METH_O, NULL},
	 { "LinearTsrPricer_swigregister", LinearTsrPricer_swigregister, METH_O, NULL},
	 { "LinearTsrPricer_swiginit", LinearTsrPricer_swiginit, METH_VARARGS, NULL},
	 { "new_LinearTsrPricerSettings", _wrap_new_LinearTsrPricerSettings, METH_NOARGS, NULL},
	 { "LinearTsrPricerSettings_withRateBound", _wrap_LinearTsrPricerSettings_withRateBound, METH_VARARGS, NULL},
	 { "LinearTsrPricerSettings_withVegaRatio", _wrap_LinearTsrPricerSettings_withVegaRatio, METH_VARARGS, NULL},
	 { "LinearTsrPricerSettings_withPriceThreshold", _wrap_LinearTsrPricerSettings_withPriceThreshold, METH_VARARGS, NULL},
	 { "LinearTsrPricerSettings_withBSStdDevs", _wrap_LinearTsrPricerSettings_withBSStdDevs, METH_VARARGS, NULL},
	 { "delete_LinearTsrPricerSettings", _wrap_delete_LinearTsrPricerSettings, METH_O, NULL},
	 { "LinearTsrPricerSettings_swigregister", LinearTsrPricerSettings_swigregister, METH_O, NULL},
	 { "LinearTsrPricerSettings_swiginit", LinearTsrPricerSettings_swiginit, METH_VARARGS, NULL},
	 { "CmsSpreadCouponPricer_correlation", _wrap_CmsSpreadCouponPricer_correlation, METH_O, NULL},
	 { "CmsSpreadCouponPricer_setCorrelation", _wrap_CmsSpreadCouponPricer_setCorrelation, METH_VARARGS, NULL},
	 { "delete_CmsSpreadCouponPricer", _wrap_delete_CmsSpreadCouponPricer, METH_O, NULL},
	 { "CmsSpreadCouponPricer_swigregister", CmsSpreadCouponPricer_swigregister, METH_O, NULL},
	 { "new_LognormalCmsSpreadPricer", _wrap_new_LognormalCmsSpreadPricer, METH_VARARGS, NULL},
	 { "LognormalCmsSpreadPricer_swapletPrice", _wrap_LognormalCmsSpreadPricer_swapletPrice, METH_O, NULL},
	 { "LognormalCmsSpreadPricer_swapletRate", _wrap_LognormalCmsSpreadPricer_swapletRate, METH_O, NULL},
	 { "LognormalCmsSpreadPricer_capletPrice", _wrap_LognormalCmsSpreadPricer_capletPrice, METH_VARARGS, NULL},
	 { "LognormalCmsSpreadPricer_capletRate", _wrap_LognormalCmsSpreadPricer_capletRate, METH_VARARGS, NULL},
	 { "LognormalCmsSpreadPricer_floorletPrice", _wrap_LognormalCmsSpreadPricer_floorletPrice, METH_VARARGS, NULL},
	 { "LognormalCmsSpreadPricer_floorletRate", _wrap_LognormalCmsSpreadPricer_floorletRate, METH_VARARGS, NULL},
	 { "delete_LognormalCmsSpreadPricer", _wrap_delete_LognormalCmsSpreadPricer, METH_O, NULL},
	 { "LognormalCmsSpreadPricer_swigregister", LognormalCmsSpreadPricer_swigregister, METH_O, NULL},
	 { "LognormalCmsSpreadPricer_swiginit", LognormalCmsSpreadPricer_swiginit, METH_VARARGS, NULL},
	 { "FixedRateLeg", (PyCFunction)(void(*)(void))_wrap_FixedRateLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IborLeg", (PyCFunction)(void(*)(void))_wrap_IborLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "OvernightLeg", (PyCFunction)(void(*)(void))_wrap_OvernightLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CmsLeg", (PyCFunction)(void(*)(void))_wrap_CmsLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CmsZeroLeg", (PyCFunction)(void(*)(void))_wrap_CmsZeroLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CmsSpreadLeg", (PyCFunction)(void(*)(void))_wrap_CmsSpreadLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_Duration", _wrap_new_Duration, METH_NOARGS, NULL},
	 { "delete_Duration", _wrap_delete_Duration, METH_O, NULL},
	 { "Duration_swigregister", Duration_swigregister, METH_O, NULL},
	 { "Duration_swiginit", Duration_swiginit, METH_VARARGS, NULL},
	 { "CashFlows_startDate", _wrap_CashFlows_startDate, METH_O, NULL},
	 { "CashFlows_maturityDate", _wrap_CashFlows_maturityDate, METH_O, NULL},
	 { "CashFlows_previousCashFlowDate", _wrap_CashFlows_previousCashFlowDate, METH_VARARGS, NULL},
	 { "CashFlows_nextCashFlowDate", _wrap_CashFlows_nextCashFlowDate, METH_VARARGS, NULL},
	 { "CashFlows_previousCashFlow", _wrap_CashFlows_previousCashFlow, METH_VARARGS, NULL},
	 { "CashFlows_nextCashFlow", _wrap_CashFlows_nextCashFlow, METH_VARARGS, NULL},
	 { "CashFlows_npv", _wrap_CashFlows_npv, METH_VARARGS, NULL},
	 { "CashFlows_bps", _wrap_CashFlows_bps, METH_VARARGS, NULL},
	 { "CashFlows_atmRate", _wrap_CashFlows_atmRate, METH_VARARGS, NULL},
	 { "CashFlows_yieldRate", _wrap_CashFlows_yieldRate, METH_VARARGS, NULL},
	 { "CashFlows_duration", _wrap_CashFlows_duration, METH_VARARGS, NULL},
	 { "CashFlows_convexity", _wrap_CashFlows_convexity, METH_VARARGS, NULL},
	 { "CashFlows_basisPointValue", _wrap_CashFlows_basisPointValue, METH_VARARGS, NULL},
	 { "CashFlows_zSpread", _wrap_CashFlows_zSpread, METH_VARARGS, NULL},
	 { "delete_CashFlows", _wrap_delete_CashFlows, METH_O, NULL},
	 { "CashFlows_swigregister", CashFlows_swigregister, METH_O, NULL},
	 { "CalibrationHelper_calibrationError", _wrap_CalibrationHelper_calibrationError, METH_O, NULL},
	 { "delete_CalibrationHelper", _wrap_delete_CalibrationHelper, METH_O, NULL},
	 { "CalibrationHelper_swigregister", CalibrationHelper_swigregister, METH_O, NULL},
	 { "BlackCalibrationHelper_setPricingEngine", _wrap_BlackCalibrationHelper_setPricingEngine, METH_VARARGS, NULL},
	 { "BlackCalibrationHelper_marketValue", _wrap_BlackCalibrationHelper_marketValue, METH_O, NULL},
	 { "BlackCalibrationHelper_modelValue", _wrap_BlackCalibrationHelper_modelValue, METH_O, NULL},
	 { "BlackCalibrationHelper_impliedVolatility", _wrap_BlackCalibrationHelper_impliedVolatility, METH_VARARGS, NULL},
	 { "BlackCalibrationHelper_blackPrice", _wrap_BlackCalibrationHelper_blackPrice, METH_VARARGS, NULL},
	 { "BlackCalibrationHelper_volatility", _wrap_BlackCalibrationHelper_volatility, METH_O, NULL},
	 { "BlackCalibrationHelper_volatilityType", _wrap_BlackCalibrationHelper_volatilityType, METH_O, NULL},
	 { "BlackCalibrationHelper_calibrationError", _wrap_BlackCalibrationHelper_calibrationError, METH_O, NULL},
	 { "delete_BlackCalibrationHelper", _wrap_delete_BlackCalibrationHelper, METH_O, NULL},
	 { "BlackCalibrationHelper_swigregister", BlackCalibrationHelper_swigregister, METH_O, NULL},
	 { "as_black_helper", _wrap_as_black_helper, METH_O, NULL},
	 { "as_swaption_helper", _wrap_as_swaption_helper, METH_O, NULL},
	 { "new_SwaptionHelper", _wrap_new_SwaptionHelper, METH_VARARGS, NULL},
	 { "SwaptionHelper_underlyingSwap", _wrap_SwaptionHelper_underlyingSwap, METH_O, NULL},
	 { "SwaptionHelper_swaption", _wrap_SwaptionHelper_swaption, METH_O, NULL},
	 { "SwaptionHelper_times", _wrap_SwaptionHelper_times, METH_O, NULL},
	 { "SwaptionHelper_swaptionExpiryDate", _wrap_SwaptionHelper_swaptionExpiryDate, METH_O, NULL},
	 { "SwaptionHelper_swaptionStrike", _wrap_SwaptionHelper_swaptionStrike, METH_O, NULL},
	 { "SwaptionHelper_swaptionNominal", _wrap_SwaptionHelper_swaptionNominal, METH_O, NULL},
	 { "SwaptionHelper_swaptionMaturityDate", _wrap_SwaptionHelper_swaptionMaturityDate, METH_O, NULL},
	 { "delete_SwaptionHelper", _wrap_delete_SwaptionHelper, METH_O, NULL},
	 { "SwaptionHelper_swigregister", SwaptionHelper_swigregister, METH_O, NULL},
	 { "SwaptionHelper_swiginit", SwaptionHelper_swiginit, METH_VARARGS, NULL},
	 { "new_CapHelper", _wrap_new_CapHelper, METH_VARARGS, NULL},
	 { "CapHelper_times", _wrap_CapHelper_times, METH_O, NULL},
	 { "delete_CapHelper", _wrap_delete_CapHelper, METH_O, NULL},
	 { "CapHelper_swigregister", CapHelper_swigregister, METH_O, NULL},
	 { "CapHelper_swiginit", CapHelper_swiginit, METH_VARARGS, NULL},
	 { "new_HestonModelHelper", _wrap_new_HestonModelHelper, METH_VARARGS, NULL},
	 { "delete_HestonModelHelper", _wrap_delete_HestonModelHelper, METH_O, NULL},
	 { "HestonModelHelper_swigregister", HestonModelHelper_swigregister, METH_O, NULL},
	 { "HestonModelHelper_swiginit", HestonModelHelper_swiginit, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_iterator", _wrap_CalibrationHelperVector_iterator, METH_O, NULL},
	 { "CalibrationHelperVector___nonzero__", _wrap_CalibrationHelperVector___nonzero__, METH_O, NULL},
	 { "CalibrationHelperVector___bool__", _wrap_CalibrationHelperVector___bool__, METH_O, NULL},
	 { "CalibrationHelperVector___len__", _wrap_CalibrationHelperVector___len__, METH_O, NULL},
	 { "CalibrationHelperVector___getslice__", _wrap_CalibrationHelperVector___getslice__, METH_VARARGS, NULL},
	 { "CalibrationHelperVector___setslice__", _wrap_CalibrationHelperVector___setslice__, METH_VARARGS, NULL},
	 { "CalibrationHelperVector___delslice__", _wrap_CalibrationHelperVector___delslice__, METH_VARARGS, NULL},
	 { "CalibrationHelperVector___delitem__", _wrap_CalibrationHelperVector___delitem__, METH_VARARGS, NULL},
	 { "CalibrationHelperVector___getitem__", _wrap_CalibrationHelperVector___getitem__, METH_VARARGS, NULL},
	 { "CalibrationHelperVector___setitem__", _wrap_CalibrationHelperVector___setitem__, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_pop", _wrap_CalibrationHelperVector_pop, METH_O, NULL},
	 { "CalibrationHelperVector_append", _wrap_CalibrationHelperVector_append, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_empty", _wrap_CalibrationHelperVector_empty, METH_O, NULL},
	 { "CalibrationHelperVector_size", _wrap_CalibrationHelperVector_size, METH_O, NULL},
	 { "CalibrationHelperVector_swap", _wrap_CalibrationHelperVector_swap, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_begin", _wrap_CalibrationHelperVector_begin, METH_O, NULL},
	 { "CalibrationHelperVector_end", _wrap_CalibrationHelperVector_end, METH_O, NULL},
	 { "CalibrationHelperVector_rbegin", _wrap_CalibrationHelperVector_rbegin, METH_O, NULL},
	 { "CalibrationHelperVector_rend", _wrap_CalibrationHelperVector_rend, METH_O, NULL},
	 { "CalibrationHelperVector_clear", _wrap_CalibrationHelperVector_clear, METH_O, NULL},
	 { "CalibrationHelperVector_get_allocator", _wrap_CalibrationHelperVector_get_allocator, METH_O, NULL},
	 { "CalibrationHelperVector_pop_back", _wrap_CalibrationHelperVector_pop_back, METH_O, NULL},
	 { "CalibrationHelperVector_erase", _wrap_CalibrationHelperVector_erase, METH_VARARGS, NULL},
	 { "new_CalibrationHelperVector", _wrap_new_CalibrationHelperVector, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_push_back", _wrap_CalibrationHelperVector_push_back, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_front", _wrap_CalibrationHelperVector_front, METH_O, NULL},
	 { "CalibrationHelperVector_back", _wrap_CalibrationHelperVector_back, METH_O, NULL},
	 { "CalibrationHelperVector_assign", _wrap_CalibrationHelperVector_assign, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_resize", _wrap_CalibrationHelperVector_resize, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_insert", _wrap_CalibrationHelperVector_insert, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_reserve", _wrap_CalibrationHelperVector_reserve, METH_VARARGS, NULL},
	 { "CalibrationHelperVector_capacity", _wrap_CalibrationHelperVector_capacity, METH_O, NULL},
	 { "delete_CalibrationHelperVector", _wrap_delete_CalibrationHelperVector, METH_O, NULL},
	 { "CalibrationHelperVector_swigregister", CalibrationHelperVector_swigregister, METH_O, NULL},
	 { "CalibrationHelperVector_swiginit", CalibrationHelperVector_swiginit, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_iterator", _wrap_BlackCalibrationHelperVector_iterator, METH_O, NULL},
	 { "BlackCalibrationHelperVector___nonzero__", _wrap_BlackCalibrationHelperVector___nonzero__, METH_O, NULL},
	 { "BlackCalibrationHelperVector___bool__", _wrap_BlackCalibrationHelperVector___bool__, METH_O, NULL},
	 { "BlackCalibrationHelperVector___len__", _wrap_BlackCalibrationHelperVector___len__, METH_O, NULL},
	 { "BlackCalibrationHelperVector___getslice__", _wrap_BlackCalibrationHelperVector___getslice__, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector___setslice__", _wrap_BlackCalibrationHelperVector___setslice__, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector___delslice__", _wrap_BlackCalibrationHelperVector___delslice__, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector___delitem__", _wrap_BlackCalibrationHelperVector___delitem__, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector___getitem__", _wrap_BlackCalibrationHelperVector___getitem__, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector___setitem__", _wrap_BlackCalibrationHelperVector___setitem__, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_pop", _wrap_BlackCalibrationHelperVector_pop, METH_O, NULL},
	 { "BlackCalibrationHelperVector_append", _wrap_BlackCalibrationHelperVector_append, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_empty", _wrap_BlackCalibrationHelperVector_empty, METH_O, NULL},
	 { "BlackCalibrationHelperVector_size", _wrap_BlackCalibrationHelperVector_size, METH_O, NULL},
	 { "BlackCalibrationHelperVector_swap", _wrap_BlackCalibrationHelperVector_swap, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_begin", _wrap_BlackCalibrationHelperVector_begin, METH_O, NULL},
	 { "BlackCalibrationHelperVector_end", _wrap_BlackCalibrationHelperVector_end, METH_O, NULL},
	 { "BlackCalibrationHelperVector_rbegin", _wrap_BlackCalibrationHelperVector_rbegin, METH_O, NULL},
	 { "BlackCalibrationHelperVector_rend", _wrap_BlackCalibrationHelperVector_rend, METH_O, NULL},
	 { "BlackCalibrationHelperVector_clear", _wrap_BlackCalibrationHelperVector_clear, METH_O, NULL},
	 { "BlackCalibrationHelperVector_get_allocator", _wrap_BlackCalibrationHelperVector_get_allocator, METH_O, NULL},
	 { "BlackCalibrationHelperVector_pop_back", _wrap_BlackCalibrationHelperVector_pop_back, METH_O, NULL},
	 { "BlackCalibrationHelperVector_erase", _wrap_BlackCalibrationHelperVector_erase, METH_VARARGS, NULL},
	 { "new_BlackCalibrationHelperVector", _wrap_new_BlackCalibrationHelperVector, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_push_back", _wrap_BlackCalibrationHelperVector_push_back, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_front", _wrap_BlackCalibrationHelperVector_front, METH_O, NULL},
	 { "BlackCalibrationHelperVector_back", _wrap_BlackCalibrationHelperVector_back, METH_O, NULL},
	 { "BlackCalibrationHelperVector_assign", _wrap_BlackCalibrationHelperVector_assign, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_resize", _wrap_BlackCalibrationHelperVector_resize, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_insert", _wrap_BlackCalibrationHelperVector_insert, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_reserve", _wrap_BlackCalibrationHelperVector_reserve, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_capacity", _wrap_BlackCalibrationHelperVector_capacity, METH_O, NULL},
	 { "delete_BlackCalibrationHelperVector", _wrap_delete_BlackCalibrationHelperVector, METH_O, NULL},
	 { "BlackCalibrationHelperVector_swigregister", BlackCalibrationHelperVector_swigregister, METH_O, NULL},
	 { "BlackCalibrationHelperVector_swiginit", BlackCalibrationHelperVector_swiginit, METH_VARARGS, NULL},
	 { "CalibratedModel_params", _wrap_CalibratedModel_params, METH_O, NULL},
	 { "CalibratedModel_calibrate", _wrap_CalibratedModel_calibrate, METH_VARARGS, NULL},
	 { "CalibratedModel_setParams", _wrap_CalibratedModel_setParams, METH_VARARGS, NULL},
	 { "CalibratedModel_value", _wrap_CalibratedModel_value, METH_VARARGS, NULL},
	 { "CalibratedModel_constraint", _wrap_CalibratedModel_constraint, METH_O, NULL},
	 { "CalibratedModel_endCriteria", _wrap_CalibratedModel_endCriteria, METH_O, NULL},
	 { "CalibratedModel_problemValues", _wrap_CalibratedModel_problemValues, METH_O, NULL},
	 { "CalibratedModel_functionEvaluation", _wrap_CalibratedModel_functionEvaluation, METH_O, NULL},
	 { "delete_CalibratedModel", _wrap_delete_CalibratedModel, METH_O, NULL},
	 { "CalibratedModel_swigregister", CalibratedModel_swigregister, METH_O, NULL},
	 { "TermStructureConsistentModel_termStructure", _wrap_TermStructureConsistentModel_termStructure, METH_O, NULL},
	 { "delete_TermStructureConsistentModel", _wrap_delete_TermStructureConsistentModel, METH_O, NULL},
	 { "TermStructureConsistentModel_swigregister", TermStructureConsistentModel_swigregister, METH_O, NULL},
	 { "new_CalibratedModelHandle", _wrap_new_CalibratedModelHandle, METH_VARARGS, NULL},
	 { "CalibratedModelHandle___deref__", _wrap_CalibratedModelHandle___deref__, METH_O, NULL},
	 { "CalibratedModelHandle_currentLink", _wrap_CalibratedModelHandle_currentLink, METH_O, NULL},
	 { "CalibratedModelHandle___nonzero__", _wrap_CalibratedModelHandle___nonzero__, METH_O, NULL},
	 { "CalibratedModelHandle___bool__", _wrap_CalibratedModelHandle___bool__, METH_O, NULL},
	 { "CalibratedModelHandle_asObservable", _wrap_CalibratedModelHandle_asObservable, METH_O, NULL},
	 { "delete_CalibratedModelHandle", _wrap_delete_CalibratedModelHandle, METH_O, NULL},
	 { "CalibratedModelHandle_params", _wrap_CalibratedModelHandle_params, METH_O, NULL},
	 { "CalibratedModelHandle_calibrate", _wrap_CalibratedModelHandle_calibrate, METH_VARARGS, NULL},
	 { "CalibratedModelHandle_setParams", _wrap_CalibratedModelHandle_setParams, METH_VARARGS, NULL},
	 { "CalibratedModelHandle_value", _wrap_CalibratedModelHandle_value, METH_VARARGS, NULL},
	 { "CalibratedModelHandle_constraint", _wrap_CalibratedModelHandle_constraint, METH_O, NULL},
	 { "CalibratedModelHandle_endCriteria", _wrap_CalibratedModelHandle_endCriteria, METH_O, NULL},
	 { "CalibratedModelHandle_problemValues", _wrap_CalibratedModelHandle_problemValues, METH_O, NULL},
	 { "CalibratedModelHandle_functionEvaluation", _wrap_CalibratedModelHandle_functionEvaluation, METH_O, NULL},
	 { "CalibratedModelHandle_swigregister", CalibratedModelHandle_swigregister, METH_O, NULL},
	 { "CalibratedModelHandle_swiginit", CalibratedModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableCalibratedModelHandle", _wrap_new_RelinkableCalibratedModelHandle, METH_VARARGS, NULL},
	 { "RelinkableCalibratedModelHandle_linkTo", _wrap_RelinkableCalibratedModelHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableCalibratedModelHandle_reset", _wrap_RelinkableCalibratedModelHandle_reset, METH_O, NULL},
	 { "delete_RelinkableCalibratedModelHandle", _wrap_delete_RelinkableCalibratedModelHandle, METH_O, NULL},
	 { "RelinkableCalibratedModelHandle_swigregister", RelinkableCalibratedModelHandle_swigregister, METH_O, NULL},
	 { "RelinkableCalibratedModelHandle_swiginit", RelinkableCalibratedModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_TimeGrid", _wrap_new_TimeGrid, METH_VARARGS, NULL},
	 { "TimeGrid___len__", _wrap_TimeGrid___len__, METH_O, NULL},
	 { "TimeGrid___getitem__", _wrap_TimeGrid___getitem__, METH_VARARGS, NULL},
	 { "TimeGrid_dt", _wrap_TimeGrid_dt, METH_VARARGS, NULL},
	 { "delete_TimeGrid", _wrap_delete_TimeGrid, METH_O, NULL},
	 { "TimeGrid_swigregister", TimeGrid_swigregister, METH_O, NULL},
	 { "TimeGrid_swiginit", TimeGrid_swiginit, METH_VARARGS, NULL},
	 { "new_Parameter", _wrap_new_Parameter, METH_NOARGS, NULL},
	 { "Parameter_params", _wrap_Parameter_params, METH_O, NULL},
	 { "Parameter_setParam", _wrap_Parameter_setParam, METH_VARARGS, NULL},
	 { "Parameter_testParams", _wrap_Parameter_testParams, METH_VARARGS, NULL},
	 { "Parameter_size", _wrap_Parameter_size, METH_O, NULL},
	 { "Parameter___call__", _wrap_Parameter___call__, METH_VARARGS, NULL},
	 { "Parameter_constraint", _wrap_Parameter_constraint, METH_O, NULL},
	 { "delete_Parameter", _wrap_delete_Parameter, METH_O, NULL},
	 { "Parameter_swigregister", Parameter_swigregister, METH_O, NULL},
	 { "Parameter_swiginit", Parameter_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantParameter", _wrap_new_ConstantParameter, METH_VARARGS, NULL},
	 { "delete_ConstantParameter", _wrap_delete_ConstantParameter, METH_O, NULL},
	 { "ConstantParameter_swigregister", ConstantParameter_swigregister, METH_O, NULL},
	 { "ConstantParameter_swiginit", ConstantParameter_swiginit, METH_VARARGS, NULL},
	 { "new_NullParameter", _wrap_new_NullParameter, METH_NOARGS, NULL},
	 { "delete_NullParameter", _wrap_delete_NullParameter, METH_O, NULL},
	 { "NullParameter_swigregister", NullParameter_swigregister, METH_O, NULL},
	 { "NullParameter_swiginit", NullParameter_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseConstantParameter", _wrap_new_PiecewiseConstantParameter, METH_VARARGS, NULL},
	 { "delete_PiecewiseConstantParameter", _wrap_delete_PiecewiseConstantParameter, METH_O, NULL},
	 { "PiecewiseConstantParameter_swigregister", PiecewiseConstantParameter_swigregister, METH_O, NULL},
	 { "PiecewiseConstantParameter_swiginit", PiecewiseConstantParameter_swiginit, METH_VARARGS, NULL},
	 { "Payoff___call__", _wrap_Payoff___call__, METH_VARARGS, NULL},
	 { "delete_Payoff", _wrap_delete_Payoff, METH_O, NULL},
	 { "Payoff_swigregister", Payoff_swigregister, METH_O, NULL},
	 { "Option_payoff", _wrap_Option_payoff, METH_O, NULL},
	 { "Option_exercise", _wrap_Option_exercise, METH_O, NULL},
	 { "delete_Option", _wrap_delete_Option, METH_O, NULL},
	 { "Option_swigregister", Option_swigregister, METH_O, NULL},
	 { "new_Barrier", _wrap_new_Barrier, METH_NOARGS, NULL},
	 { "delete_Barrier", _wrap_delete_Barrier, METH_O, NULL},
	 { "Barrier_swigregister", Barrier_swigregister, METH_O, NULL},
	 { "Barrier_swiginit", Barrier_swiginit, METH_VARARGS, NULL},
	 { "new_DoubleBarrier", _wrap_new_DoubleBarrier, METH_NOARGS, NULL},
	 { "delete_DoubleBarrier", _wrap_delete_DoubleBarrier, METH_O, NULL},
	 { "DoubleBarrier_swigregister", DoubleBarrier_swigregister, METH_O, NULL},
	 { "DoubleBarrier_swiginit", DoubleBarrier_swiginit, METH_VARARGS, NULL},
	 { "TypePayoff_optionType", _wrap_TypePayoff_optionType, METH_O, NULL},
	 { "delete_TypePayoff", _wrap_delete_TypePayoff, METH_O, NULL},
	 { "TypePayoff_swigregister", TypePayoff_swigregister, METH_O, NULL},
	 { "StrikedTypePayoff_strike", _wrap_StrikedTypePayoff_strike, METH_O, NULL},
	 { "delete_StrikedTypePayoff", _wrap_delete_StrikedTypePayoff, METH_O, NULL},
	 { "StrikedTypePayoff_swigregister", StrikedTypePayoff_swigregister, METH_O, NULL},
	 { "OneAssetOption_delta", _wrap_OneAssetOption_delta, METH_O, NULL},
	 { "OneAssetOption_deltaForward", _wrap_OneAssetOption_deltaForward, METH_O, NULL},
	 { "OneAssetOption_elasticity", _wrap_OneAssetOption_elasticity, METH_O, NULL},
	 { "OneAssetOption_gamma", _wrap_OneAssetOption_gamma, METH_O, NULL},
	 { "OneAssetOption_theta", _wrap_OneAssetOption_theta, METH_O, NULL},
	 { "OneAssetOption_thetaPerDay", _wrap_OneAssetOption_thetaPerDay, METH_O, NULL},
	 { "OneAssetOption_vega", _wrap_OneAssetOption_vega, METH_O, NULL},
	 { "OneAssetOption_rho", _wrap_OneAssetOption_rho, METH_O, NULL},
	 { "OneAssetOption_dividendRho", _wrap_OneAssetOption_dividendRho, METH_O, NULL},
	 { "OneAssetOption_strikeSensitivity", _wrap_OneAssetOption_strikeSensitivity, METH_O, NULL},
	 { "OneAssetOption_itmCashProbability", _wrap_OneAssetOption_itmCashProbability, METH_O, NULL},
	 { "delete_OneAssetOption", _wrap_delete_OneAssetOption, METH_O, NULL},
	 { "OneAssetOption_swigregister", OneAssetOption_swigregister, METH_O, NULL},
	 { "new_VanillaOption", _wrap_new_VanillaOption, METH_VARARGS, NULL},
	 { "VanillaOption_impliedVolatility", _wrap_VanillaOption_impliedVolatility, METH_VARARGS, NULL},
	 { "VanillaOption_priceCurve", _wrap_VanillaOption_priceCurve, METH_O, NULL},
	 { "delete_VanillaOption", _wrap_delete_VanillaOption, METH_O, NULL},
	 { "VanillaOption_swigregister", VanillaOption_swigregister, METH_O, NULL},
	 { "VanillaOption_swiginit", VanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_CalibrationPair", _wrap_new_CalibrationPair, METH_VARARGS, NULL},
	 { "CalibrationPair_first_set", _wrap_CalibrationPair_first_set, METH_VARARGS, NULL},
	 { "CalibrationPair_first_get", _wrap_CalibrationPair_first_get, METH_O, NULL},
	 { "CalibrationPair_second_set", _wrap_CalibrationPair_second_set, METH_VARARGS, NULL},
	 { "CalibrationPair_second_get", _wrap_CalibrationPair_second_get, METH_O, NULL},
	 { "delete_CalibrationPair", _wrap_delete_CalibrationPair, METH_O, NULL},
	 { "CalibrationPair_swigregister", CalibrationPair_swigregister, METH_O, NULL},
	 { "CalibrationPair_swiginit", CalibrationPair_swiginit, METH_VARARGS, NULL},
	 { "CalibrationSet_iterator", _wrap_CalibrationSet_iterator, METH_O, NULL},
	 { "CalibrationSet___nonzero__", _wrap_CalibrationSet___nonzero__, METH_O, NULL},
	 { "CalibrationSet___bool__", _wrap_CalibrationSet___bool__, METH_O, NULL},
	 { "CalibrationSet___len__", _wrap_CalibrationSet___len__, METH_O, NULL},
	 { "CalibrationSet___getslice__", _wrap_CalibrationSet___getslice__, METH_VARARGS, NULL},
	 { "CalibrationSet___setslice__", _wrap_CalibrationSet___setslice__, METH_VARARGS, NULL},
	 { "CalibrationSet___delslice__", _wrap_CalibrationSet___delslice__, METH_VARARGS, NULL},
	 { "CalibrationSet___delitem__", _wrap_CalibrationSet___delitem__, METH_VARARGS, NULL},
	 { "CalibrationSet___getitem__", _wrap_CalibrationSet___getitem__, METH_VARARGS, NULL},
	 { "CalibrationSet___setitem__", _wrap_CalibrationSet___setitem__, METH_VARARGS, NULL},
	 { "CalibrationSet_pop", _wrap_CalibrationSet_pop, METH_O, NULL},
	 { "CalibrationSet_append", _wrap_CalibrationSet_append, METH_VARARGS, NULL},
	 { "CalibrationSet_empty", _wrap_CalibrationSet_empty, METH_O, NULL},
	 { "CalibrationSet_size", _wrap_CalibrationSet_size, METH_O, NULL},
	 { "CalibrationSet_swap", _wrap_CalibrationSet_swap, METH_VARARGS, NULL},
	 { "CalibrationSet_begin", _wrap_CalibrationSet_begin, METH_O, NULL},
	 { "CalibrationSet_end", _wrap_CalibrationSet_end, METH_O, NULL},
	 { "CalibrationSet_rbegin", _wrap_CalibrationSet_rbegin, METH_O, NULL},
	 { "CalibrationSet_rend", _wrap_CalibrationSet_rend, METH_O, NULL},
	 { "CalibrationSet_clear", _wrap_CalibrationSet_clear, METH_O, NULL},
	 { "CalibrationSet_get_allocator", _wrap_CalibrationSet_get_allocator, METH_O, NULL},
	 { "CalibrationSet_pop_back", _wrap_CalibrationSet_pop_back, METH_O, NULL},
	 { "CalibrationSet_erase", _wrap_CalibrationSet_erase, METH_VARARGS, NULL},
	 { "new_CalibrationSet", _wrap_new_CalibrationSet, METH_VARARGS, NULL},
	 { "CalibrationSet_push_back", _wrap_CalibrationSet_push_back, METH_VARARGS, NULL},
	 { "CalibrationSet_front", _wrap_CalibrationSet_front, METH_O, NULL},
	 { "CalibrationSet_back", _wrap_CalibrationSet_back, METH_O, NULL},
	 { "CalibrationSet_assign", _wrap_CalibrationSet_assign, METH_VARARGS, NULL},
	 { "CalibrationSet_resize", _wrap_CalibrationSet_resize, METH_VARARGS, NULL},
	 { "CalibrationSet_insert", _wrap_CalibrationSet_insert, METH_VARARGS, NULL},
	 { "CalibrationSet_reserve", _wrap_CalibrationSet_reserve, METH_VARARGS, NULL},
	 { "CalibrationSet_capacity", _wrap_CalibrationSet_capacity, METH_O, NULL},
	 { "delete_CalibrationSet", _wrap_delete_CalibrationSet, METH_O, NULL},
	 { "CalibrationSet_swigregister", CalibrationSet_swigregister, METH_O, NULL},
	 { "CalibrationSet_swiginit", CalibrationSet_swiginit, METH_VARARGS, NULL},
	 { "new_EuropeanOption", _wrap_new_EuropeanOption, METH_VARARGS, NULL},
	 { "delete_EuropeanOption", _wrap_delete_EuropeanOption, METH_O, NULL},
	 { "EuropeanOption_swigregister", EuropeanOption_swigregister, METH_O, NULL},
	 { "EuropeanOption_swiginit", EuropeanOption_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardVanillaOption", _wrap_new_ForwardVanillaOption, METH_VARARGS, NULL},
	 { "delete_ForwardVanillaOption", _wrap_delete_ForwardVanillaOption, METH_O, NULL},
	 { "ForwardVanillaOption_swigregister", ForwardVanillaOption_swigregister, METH_O, NULL},
	 { "ForwardVanillaOption_swiginit", ForwardVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoVanillaOption", _wrap_new_QuantoVanillaOption, METH_VARARGS, NULL},
	 { "QuantoVanillaOption_qvega", _wrap_QuantoVanillaOption_qvega, METH_O, NULL},
	 { "QuantoVanillaOption_qrho", _wrap_QuantoVanillaOption_qrho, METH_O, NULL},
	 { "QuantoVanillaOption_qlambda", _wrap_QuantoVanillaOption_qlambda, METH_O, NULL},
	 { "delete_QuantoVanillaOption", _wrap_delete_QuantoVanillaOption, METH_O, NULL},
	 { "QuantoVanillaOption_swigregister", QuantoVanillaOption_swigregister, METH_O, NULL},
	 { "QuantoVanillaOption_swiginit", QuantoVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoForwardVanillaOption", _wrap_new_QuantoForwardVanillaOption, METH_VARARGS, NULL},
	 { "delete_QuantoForwardVanillaOption", _wrap_delete_QuantoForwardVanillaOption, METH_O, NULL},
	 { "QuantoForwardVanillaOption_swigregister", QuantoForwardVanillaOption_swigregister, METH_O, NULL},
	 { "QuantoForwardVanillaOption_swiginit", QuantoForwardVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "MultiAssetOption_delta", _wrap_MultiAssetOption_delta, METH_O, NULL},
	 { "MultiAssetOption_gamma", _wrap_MultiAssetOption_gamma, METH_O, NULL},
	 { "MultiAssetOption_theta", _wrap_MultiAssetOption_theta, METH_O, NULL},
	 { "MultiAssetOption_vega", _wrap_MultiAssetOption_vega, METH_O, NULL},
	 { "MultiAssetOption_rho", _wrap_MultiAssetOption_rho, METH_O, NULL},
	 { "MultiAssetOption_dividendRho", _wrap_MultiAssetOption_dividendRho, METH_O, NULL},
	 { "delete_MultiAssetOption", _wrap_delete_MultiAssetOption, METH_O, NULL},
	 { "MultiAssetOption_swigregister", MultiAssetOption_swigregister, METH_O, NULL},
	 { "new_AnalyticEuropeanEngine", _wrap_new_AnalyticEuropeanEngine, METH_O, NULL},
	 { "delete_AnalyticEuropeanEngine", _wrap_delete_AnalyticEuropeanEngine, METH_O, NULL},
	 { "AnalyticEuropeanEngine_swigregister", AnalyticEuropeanEngine_swigregister, METH_O, NULL},
	 { "AnalyticEuropeanEngine_swiginit", AnalyticEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_HestonModel", _wrap_new_HestonModel, METH_O, NULL},
	 { "HestonModel_theta", _wrap_HestonModel_theta, METH_O, NULL},
	 { "HestonModel_kappa", _wrap_HestonModel_kappa, METH_O, NULL},
	 { "HestonModel_sigma", _wrap_HestonModel_sigma, METH_O, NULL},
	 { "HestonModel_rho", _wrap_HestonModel_rho, METH_O, NULL},
	 { "HestonModel_v0", _wrap_HestonModel_v0, METH_O, NULL},
	 { "delete_HestonModel", _wrap_delete_HestonModel, METH_O, NULL},
	 { "HestonModel_swigregister", HestonModel_swigregister, METH_O, NULL},
	 { "HestonModel_swiginit", HestonModel_swiginit, METH_VARARGS, NULL},
	 { "new_HestonModelHandle", _wrap_new_HestonModelHandle, METH_VARARGS, NULL},
	 { "HestonModelHandle___deref__", _wrap_HestonModelHandle___deref__, METH_O, NULL},
	 { "HestonModelHandle_currentLink", _wrap_HestonModelHandle_currentLink, METH_O, NULL},
	 { "HestonModelHandle___nonzero__", _wrap_HestonModelHandle___nonzero__, METH_O, NULL},
	 { "HestonModelHandle___bool__", _wrap_HestonModelHandle___bool__, METH_O, NULL},
	 { "HestonModelHandle_asObservable", _wrap_HestonModelHandle_asObservable, METH_O, NULL},
	 { "delete_HestonModelHandle", _wrap_delete_HestonModelHandle, METH_O, NULL},
	 { "HestonModelHandle_theta", _wrap_HestonModelHandle_theta, METH_O, NULL},
	 { "HestonModelHandle_kappa", _wrap_HestonModelHandle_kappa, METH_O, NULL},
	 { "HestonModelHandle_sigma", _wrap_HestonModelHandle_sigma, METH_O, NULL},
	 { "HestonModelHandle_rho", _wrap_HestonModelHandle_rho, METH_O, NULL},
	 { "HestonModelHandle_v0", _wrap_HestonModelHandle_v0, METH_O, NULL},
	 { "HestonModelHandle_params", _wrap_HestonModelHandle_params, METH_O, NULL},
	 { "HestonModelHandle_calibrate", _wrap_HestonModelHandle_calibrate, METH_VARARGS, NULL},
	 { "HestonModelHandle_setParams", _wrap_HestonModelHandle_setParams, METH_VARARGS, NULL},
	 { "HestonModelHandle_value", _wrap_HestonModelHandle_value, METH_VARARGS, NULL},
	 { "HestonModelHandle_constraint", _wrap_HestonModelHandle_constraint, METH_O, NULL},
	 { "HestonModelHandle_endCriteria", _wrap_HestonModelHandle_endCriteria, METH_O, NULL},
	 { "HestonModelHandle_problemValues", _wrap_HestonModelHandle_problemValues, METH_O, NULL},
	 { "HestonModelHandle_functionEvaluation", _wrap_HestonModelHandle_functionEvaluation, METH_O, NULL},
	 { "HestonModelHandle_swigregister", HestonModelHandle_swigregister, METH_O, NULL},
	 { "HestonModelHandle_swiginit", HestonModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseTimeDependentHestonModel", _wrap_new_PiecewiseTimeDependentHestonModel, METH_VARARGS, NULL},
	 { "PiecewiseTimeDependentHestonModel_theta", _wrap_PiecewiseTimeDependentHestonModel_theta, METH_VARARGS, NULL},
	 { "PiecewiseTimeDependentHestonModel_kappa", _wrap_PiecewiseTimeDependentHestonModel_kappa, METH_VARARGS, NULL},
	 { "PiecewiseTimeDependentHestonModel_sigma", _wrap_PiecewiseTimeDependentHestonModel_sigma, METH_VARARGS, NULL},
	 { "PiecewiseTimeDependentHestonModel_rho", _wrap_PiecewiseTimeDependentHestonModel_rho, METH_VARARGS, NULL},
	 { "PiecewiseTimeDependentHestonModel_v0", _wrap_PiecewiseTimeDependentHestonModel_v0, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_s0", _wrap_PiecewiseTimeDependentHestonModel_s0, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_timeGrid", _wrap_PiecewiseTimeDependentHestonModel_timeGrid, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_dividendYield", _wrap_PiecewiseTimeDependentHestonModel_dividendYield, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_riskFreeRate", _wrap_PiecewiseTimeDependentHestonModel_riskFreeRate, METH_O, NULL},
	 { "delete_PiecewiseTimeDependentHestonModel", _wrap_delete_PiecewiseTimeDependentHestonModel, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_swigregister", PiecewiseTimeDependentHestonModel_swigregister, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_swiginit", PiecewiseTimeDependentHestonModel_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticHestonEngine", _wrap_new_AnalyticHestonEngine, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_chF", _wrap_AnalyticHestonEngine_chF, METH_VARARGS, NULL},
	 { "delete_AnalyticHestonEngine", _wrap_delete_AnalyticHestonEngine, METH_O, NULL},
	 { "AnalyticHestonEngine_swigregister", AnalyticHestonEngine_swigregister, METH_O, NULL},
	 { "AnalyticHestonEngine_swiginit", AnalyticHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussLaguerre", _wrap_AnalyticHestonEngine_Integration_gaussLaguerre, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussLegendre", _wrap_AnalyticHestonEngine_Integration_gaussLegendre, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussChebyshev", _wrap_AnalyticHestonEngine_Integration_gaussChebyshev, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussChebyshev2nd", _wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussLobatto", _wrap_AnalyticHestonEngine_Integration_gaussLobatto, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussKronrod", _wrap_AnalyticHestonEngine_Integration_gaussKronrod, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_simpson", _wrap_AnalyticHestonEngine_Integration_simpson, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_trapezoid", _wrap_AnalyticHestonEngine_Integration_trapezoid, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_discreteSimpson", _wrap_AnalyticHestonEngine_Integration_discreteSimpson, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_discreteTrapezoid", _wrap_AnalyticHestonEngine_Integration_discreteTrapezoid, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit", _wrap_AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_calculate", _wrap_AnalyticHestonEngine_Integration_calculate, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_numberOfEvaluations", _wrap_AnalyticHestonEngine_Integration_numberOfEvaluations, METH_O, NULL},
	 { "AnalyticHestonEngine_Integration_isAdaptiveIntegration", _wrap_AnalyticHestonEngine_Integration_isAdaptiveIntegration, METH_O, NULL},
	 { "delete_AnalyticHestonEngine_Integration", _wrap_delete_AnalyticHestonEngine_Integration, METH_O, NULL},
	 { "AnalyticHestonEngine_Integration_swigregister", AnalyticHestonEngine_Integration_swigregister, METH_O, NULL},
	 { "new_COSHestonEngine", _wrap_new_COSHestonEngine, METH_VARARGS, NULL},
	 { "delete_COSHestonEngine", _wrap_delete_COSHestonEngine, METH_O, NULL},
	 { "COSHestonEngine_swigregister", COSHestonEngine_swigregister, METH_O, NULL},
	 { "COSHestonEngine_swiginit", COSHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ExponentialFittingHestonEngine", _wrap_new_ExponentialFittingHestonEngine, METH_VARARGS, NULL},
	 { "delete_ExponentialFittingHestonEngine", _wrap_delete_ExponentialFittingHestonEngine, METH_O, NULL},
	 { "ExponentialFittingHestonEngine_swigregister", ExponentialFittingHestonEngine_swigregister, METH_O, NULL},
	 { "ExponentialFittingHestonEngine_swiginit", ExponentialFittingHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticPTDHestonEngine", _wrap_new_AnalyticPTDHestonEngine, METH_VARARGS, NULL},
	 { "delete_AnalyticPTDHestonEngine", _wrap_delete_AnalyticPTDHestonEngine, METH_O, NULL},
	 { "AnalyticPTDHestonEngine_swigregister", AnalyticPTDHestonEngine_swigregister, METH_O, NULL},
	 { "AnalyticPTDHestonEngine_swiginit", AnalyticPTDHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BatesModel", _wrap_new_BatesModel, METH_O, NULL},
	 { "BatesModel_nu", _wrap_BatesModel_nu, METH_O, NULL},
	 { "BatesModel_delta", _wrap_BatesModel_delta, METH_O, NULL},
	 { "BatesModel_lambda_parameter", _wrap_BatesModel_lambda_parameter, METH_O, NULL},
	 { "delete_BatesModel", _wrap_delete_BatesModel, METH_O, NULL},
	 { "BatesModel_swigregister", BatesModel_swigregister, METH_O, NULL},
	 { "BatesModel_swiginit", BatesModel_swiginit, METH_VARARGS, NULL},
	 { "new_BatesEngine", _wrap_new_BatesEngine, METH_VARARGS, NULL},
	 { "delete_BatesEngine", _wrap_delete_BatesEngine, METH_O, NULL},
	 { "BatesEngine_swigregister", BatesEngine_swigregister, METH_O, NULL},
	 { "BatesEngine_swiginit", BatesEngine_swiginit, METH_VARARGS, NULL},
	 { "new_IntegralEngine", _wrap_new_IntegralEngine, METH_O, NULL},
	 { "delete_IntegralEngine", _wrap_delete_IntegralEngine, METH_O, NULL},
	 { "IntegralEngine_swigregister", IntegralEngine_swigregister, METH_O, NULL},
	 { "IntegralEngine_swiginit", IntegralEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FDBermudanEngine", _wrap_new_FDBermudanEngine, METH_VARARGS, NULL},
	 { "delete_FDBermudanEngine", _wrap_delete_FDBermudanEngine, METH_O, NULL},
	 { "FDBermudanEngine_swigregister", FDBermudanEngine_swigregister, METH_O, NULL},
	 { "FDBermudanEngine_swiginit", FDBermudanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FDEuropeanEngine", _wrap_new_FDEuropeanEngine, METH_VARARGS, NULL},
	 { "delete_FDEuropeanEngine", _wrap_delete_FDEuropeanEngine, METH_O, NULL},
	 { "FDEuropeanEngine_swigregister", FDEuropeanEngine_swigregister, METH_O, NULL},
	 { "FDEuropeanEngine_swiginit", FDEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRVanillaEngine", _wrap_new_BinomialCRRVanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialCRRVanillaEngine", _wrap_delete_BinomialCRRVanillaEngine, METH_O, NULL},
	 { "BinomialCRRVanillaEngine_swigregister", BinomialCRRVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRVanillaEngine_swiginit", BinomialCRRVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRVanillaEngine", _wrap_new_BinomialJRVanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialJRVanillaEngine", _wrap_delete_BinomialJRVanillaEngine, METH_O, NULL},
	 { "BinomialJRVanillaEngine_swigregister", BinomialJRVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialJRVanillaEngine_swiginit", BinomialJRVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPVanillaEngine", _wrap_new_BinomialEQPVanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialEQPVanillaEngine", _wrap_delete_BinomialEQPVanillaEngine, METH_O, NULL},
	 { "BinomialEQPVanillaEngine_swigregister", BinomialEQPVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPVanillaEngine_swiginit", BinomialEQPVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisVanillaEngine", _wrap_new_BinomialTrigeorgisVanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialTrigeorgisVanillaEngine", _wrap_delete_BinomialTrigeorgisVanillaEngine, METH_O, NULL},
	 { "BinomialTrigeorgisVanillaEngine_swigregister", BinomialTrigeorgisVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisVanillaEngine_swiginit", BinomialTrigeorgisVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianVanillaEngine", _wrap_new_BinomialTianVanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialTianVanillaEngine", _wrap_delete_BinomialTianVanillaEngine, METH_O, NULL},
	 { "BinomialTianVanillaEngine_swigregister", BinomialTianVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialTianVanillaEngine_swiginit", BinomialTianVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRVanillaEngine", _wrap_new_BinomialLRVanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialLRVanillaEngine", _wrap_delete_BinomialLRVanillaEngine, METH_O, NULL},
	 { "BinomialLRVanillaEngine_swigregister", BinomialLRVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialLRVanillaEngine_swiginit", BinomialLRVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4VanillaEngine", _wrap_new_BinomialJ4VanillaEngine, METH_VARARGS, NULL},
	 { "delete_BinomialJ4VanillaEngine", _wrap_delete_BinomialJ4VanillaEngine, METH_O, NULL},
	 { "BinomialJ4VanillaEngine_swigregister", BinomialJ4VanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4VanillaEngine_swiginit", BinomialJ4VanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_LsmBasisSystem", _wrap_new_LsmBasisSystem, METH_NOARGS, NULL},
	 { "delete_LsmBasisSystem", _wrap_delete_LsmBasisSystem, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPREuropeanEngine", _wrap_delete_MCPREuropeanEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDEuropeanEngine", _wrap_delete_MCLDEuropeanEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPRAmericanEngine", _wrap_delete_MCPRAmericanEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDAmericanEngine", _wrap_delete_MCLDAmericanEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPREuropeanHestonEngine", _wrap_delete_MCPREuropeanHestonEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDEuropeanHestonEngine", _wrap_delete_MCLDEuropeanHestonEngine, METH_O, NULL},
	 { "MCLDEuropeanHestonEngine_swigregister", MCLDEuropeanHestonEngine_swigregister, METH_O, NULL},
	 { "MCLDEuropeanHestonEngine_swiginit", MCLDEuropeanHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FDAmericanEngine", _wrap_new_FDAmericanEngine, METH_VARARGS, NULL},
	 { "delete_FDAmericanEngine", _wrap_delete_FDAmericanEngine, METH_O, NULL},
	 { "FDAmericanEngine_swigregister", FDAmericanEngine_swigregister, METH_O, NULL},
	 { "FDAmericanEngine_swiginit", FDAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FDShoutEngine", _wrap_new_FDShoutEngine, METH_VARARGS, NULL},
	 { "delete_FDShoutEngine", _wrap_delete_FDShoutEngine, METH_O, NULL},
	 { "FDShoutEngine_swigregister", FDShoutEngine_swigregister, METH_O, NULL},
	 { "FDShoutEngine_swiginit", FDShoutEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousArithmeticAsianLevyEngine", _wrap_new_ContinuousArithmeticAsianLevyEngine, METH_VARARGS, NULL},
	 { "delete_ContinuousArithmeticAsianLevyEngine", _wrap_delete_ContinuousArithmeticAsianLevyEngine, METH_O, NULL},
	 { "ContinuousArithmeticAsianLevyEngine_swigregister", ContinuousArithmeticAsianLevyEngine_swigregister, METH_O, NULL},
	 { "ContinuousArithmeticAsianLevyEngine_swiginit", ContinuousArithmeticAsianLevyEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesAsianEngine", _wrap_new_FdBlackScholesAsianEngine, METH_VARARGS, NULL},
	 { "delete_FdBlackScholesAsianEngine", _wrap_delete_FdBlackScholesAsianEngine, METH_O, NULL},
	 { "FdBlackScholesAsianEngine_swigregister", FdBlackScholesAsianEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesAsianEngine_swiginit", FdBlackScholesAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BaroneAdesiWhaleyApproximationEngine", _wrap_new_BaroneAdesiWhaleyApproximationEngine, METH_O, NULL},
	 { "delete_BaroneAdesiWhaleyApproximationEngine", _wrap_delete_BaroneAdesiWhaleyApproximationEngine, METH_O, NULL},
	 { "BaroneAdesiWhaleyApproximationEngine_swigregister", BaroneAdesiWhaleyApproximationEngine_swigregister, METH_O, NULL},
	 { "BaroneAdesiWhaleyApproximationEngine_swiginit", BaroneAdesiWhaleyApproximationEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BjerksundStenslandApproximationEngine", _wrap_new_BjerksundStenslandApproximationEngine, METH_O, NULL},
	 { "delete_BjerksundStenslandApproximationEngine", _wrap_delete_BjerksundStenslandApproximationEngine, METH_O, NULL},
	 { "BjerksundStenslandApproximationEngine_swigregister", BjerksundStenslandApproximationEngine_swigregister, METH_O, NULL},
	 { "BjerksundStenslandApproximationEngine_swiginit", BjerksundStenslandApproximationEngine_swiginit, METH_VARARGS, NULL},
	 { "new_JuQuadraticApproximationEngine", _wrap_new_JuQuadraticApproximationEngine, METH_O, NULL},
	 { "delete_JuQuadraticApproximationEngine", _wrap_delete_JuQuadraticApproximationEngine, METH_O, NULL},
	 { "JuQuadraticApproximationEngine_swigregister", JuQuadraticApproximationEngine_swigregister, METH_O, NULL},
	 { "JuQuadraticApproximationEngine_swiginit", JuQuadraticApproximationEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDigitalAmericanEngine", _wrap_new_AnalyticDigitalAmericanEngine, METH_O, NULL},
	 { "delete_AnalyticDigitalAmericanEngine", _wrap_delete_AnalyticDigitalAmericanEngine, METH_O, NULL},
	 { "AnalyticDigitalAmericanEngine_swigregister", AnalyticDigitalAmericanEngine_swigregister, METH_O, NULL},
	 { "AnalyticDigitalAmericanEngine_swiginit", AnalyticDigitalAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDigitalAmericanKOEngine", _wrap_new_AnalyticDigitalAmericanKOEngine, METH_O, NULL},
	 { "delete_AnalyticDigitalAmericanKOEngine", _wrap_delete_AnalyticDigitalAmericanKOEngine, METH_O, NULL},
	 { "AnalyticDigitalAmericanKOEngine_swigregister", AnalyticDigitalAmericanKOEngine_swigregister, METH_O, NULL},
	 { "AnalyticDigitalAmericanKOEngine_swiginit", AnalyticDigitalAmericanKOEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DividendVanillaOption", _wrap_new_DividendVanillaOption, METH_VARARGS, NULL},
	 { "DividendVanillaOption_impliedVolatility", _wrap_DividendVanillaOption_impliedVolatility, METH_VARARGS, NULL},
	 { "delete_DividendVanillaOption", _wrap_delete_DividendVanillaOption, METH_O, NULL},
	 { "DividendVanillaOption_swigregister", DividendVanillaOption_swigregister, METH_O, NULL},
	 { "DividendVanillaOption_swiginit", DividendVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDividendEuropeanEngine", _wrap_new_AnalyticDividendEuropeanEngine, METH_O, NULL},
	 { "delete_AnalyticDividendEuropeanEngine", _wrap_delete_AnalyticDividendEuropeanEngine, METH_O, NULL},
	 { "AnalyticDividendEuropeanEngine_swigregister", AnalyticDividendEuropeanEngine_swigregister, METH_O, NULL},
	 { "AnalyticDividendEuropeanEngine_swiginit", AnalyticDividendEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FDDividendEuropeanEngineT", _wrap_new_FDDividendEuropeanEngineT, METH_VARARGS, NULL},
	 { "delete_FDDividendEuropeanEngine", _wrap_delete_FDDividendEuropeanEngine, METH_O, NULL},
	 { "FDDividendEuropeanEngine_swigregister", FDDividendEuropeanEngine_swigregister, METH_O, NULL},
	 { "new_FDDividendAmericanEngineT", _wrap_new_FDDividendAmericanEngineT, METH_VARARGS, NULL},
	 { "delete_FDDividendAmericanEngine", _wrap_delete_FDDividendAmericanEngine, METH_O, NULL},
	 { "FDDividendAmericanEngine_swigregister", FDDividendAmericanEngine_swigregister, METH_O, NULL},
	 { "new_BarrierOption", _wrap_new_BarrierOption, METH_VARARGS, NULL},
	 { "BarrierOption_impliedVolatility", _wrap_BarrierOption_impliedVolatility, METH_VARARGS, NULL},
	 { "delete_BarrierOption", _wrap_delete_BarrierOption, METH_O, NULL},
	 { "BarrierOption_swigregister", BarrierOption_swigregister, METH_O, NULL},
	 { "BarrierOption_swiginit", BarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_DividendBarrierOption", _wrap_new_DividendBarrierOption, METH_VARARGS, NULL},
	 { "delete_DividendBarrierOption", _wrap_delete_DividendBarrierOption, METH_O, NULL},
	 { "DividendBarrierOption_swigregister", DividendBarrierOption_swigregister, METH_O, NULL},
	 { "DividendBarrierOption_swiginit", DividendBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticBarrierEngine", _wrap_new_AnalyticBarrierEngine, METH_O, NULL},
	 { "delete_AnalyticBarrierEngine", _wrap_delete_AnalyticBarrierEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPRBarrierEngine", _wrap_delete_MCPRBarrierEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDBarrierEngine", _wrap_delete_MCLDBarrierEngine, METH_O, NULL},
	 { "MCLDBarrierEngine_swigregister", MCLDBarrierEngine_swigregister, METH_O, NULL},
	 { "MCLDBarrierEngine_swiginit", MCLDBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSchemeDesc", _wrap_new_FdmSchemeDesc, METH_VARARGS, NULL},
	 { "FdmSchemeDesc_type_get", _wrap_FdmSchemeDesc_type_get, METH_O, NULL},
	 { "FdmSchemeDesc_theta_get", _wrap_FdmSchemeDesc_theta_get, METH_O, NULL},
	 { "FdmSchemeDesc_mu_get", _wrap_FdmSchemeDesc_mu_get, METH_O, NULL},
	 { "FdmSchemeDesc_Douglas", _wrap_FdmSchemeDesc_Douglas, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_CrankNicolson", _wrap_FdmSchemeDesc_CrankNicolson, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_ImplicitEuler", _wrap_FdmSchemeDesc_ImplicitEuler, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_ExplicitEuler", _wrap_FdmSchemeDesc_ExplicitEuler, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_CraigSneyd", _wrap_FdmSchemeDesc_CraigSneyd, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_ModifiedCraigSneyd", _wrap_FdmSchemeDesc_ModifiedCraigSneyd, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_Hundsdorfer", _wrap_FdmSchemeDesc_Hundsdorfer, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_ModifiedHundsdorfer", _wrap_FdmSchemeDesc_ModifiedHundsdorfer, METH_NOARGS, NULL},
	 { "FdmSchemeDesc_MethodOfLines", _wrap_FdmSchemeDesc_MethodOfLines, METH_VARARGS, NULL},
	 { "FdmSchemeDesc_TrBDF2", _wrap_FdmSchemeDesc_TrBDF2, METH_NOARGS, NULL},
	 { "delete_FdmSchemeDesc", _wrap_delete_FdmSchemeDesc, METH_O, NULL},
	 { "FdmSchemeDesc_swigregister", FdmSchemeDesc_swigregister, METH_O, NULL},
	 { "FdmSchemeDesc_swiginit", FdmSchemeDesc_swiginit, METH_VARARGS, NULL},
	 { "new_FdmQuantoHelper", _wrap_new_FdmQuantoHelper, METH_VARARGS, NULL},
	 { "delete_FdmQuantoHelper", _wrap_delete_FdmQuantoHelper, METH_O, NULL},
	 { "FdmQuantoHelper_swigregister", FdmQuantoHelper_swigregister, METH_O, NULL},
	 { "FdmQuantoHelper_swiginit", FdmQuantoHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesVanillaEngine", _wrap_new_FdBlackScholesVanillaEngine, METH_VARARGS, NULL},
	 { "FdBlackScholesVanillaEngine_make", (PyCFunction)(void(*)(void))_wrap_FdBlackScholesVanillaEngine_make, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_FdBlackScholesVanillaEngine", _wrap_delete_FdBlackScholesVanillaEngine, METH_O, NULL},
	 { "FdBlackScholesVanillaEngine_swigregister", FdBlackScholesVanillaEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesVanillaEngine_swiginit", FdBlackScholesVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdOrnsteinUhlenbeckVanillaEngine", _wrap_new_FdOrnsteinUhlenbeckVanillaEngine, METH_VARARGS, NULL},
	 { "delete_FdOrnsteinUhlenbeckVanillaEngine", _wrap_delete_FdOrnsteinUhlenbeckVanillaEngine, METH_O, NULL},
	 { "FdOrnsteinUhlenbeckVanillaEngine_swigregister", FdOrnsteinUhlenbeckVanillaEngine_swigregister, METH_O, NULL},
	 { "FdOrnsteinUhlenbeckVanillaEngine_swiginit", FdOrnsteinUhlenbeckVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBatesVanillaEngine", _wrap_new_FdBatesVanillaEngine, METH_VARARGS, NULL},
	 { "delete_FdBatesVanillaEngine", _wrap_delete_FdBatesVanillaEngine, METH_O, NULL},
	 { "FdBatesVanillaEngine_swigregister", FdBatesVanillaEngine_swigregister, METH_O, NULL},
	 { "FdBatesVanillaEngine_swiginit", FdBatesVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonVanillaEngine", _wrap_new_FdHestonVanillaEngine, METH_VARARGS, NULL},
	 { "FdHestonVanillaEngine_make", (PyCFunction)(void(*)(void))_wrap_FdHestonVanillaEngine_make, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_FdHestonVanillaEngine", _wrap_delete_FdHestonVanillaEngine, METH_O, NULL},
	 { "FdHestonVanillaEngine_swigregister", FdHestonVanillaEngine_swigregister, METH_O, NULL},
	 { "FdHestonVanillaEngine_swiginit", FdHestonVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticCEVEngine", _wrap_new_AnalyticCEVEngine, METH_VARARGS, NULL},
	 { "delete_AnalyticCEVEngine", _wrap_delete_AnalyticCEVEngine, METH_O, NULL},
	 { "AnalyticCEVEngine_swigregister", AnalyticCEVEngine_swigregister, METH_O, NULL},
	 { "AnalyticCEVEngine_swiginit", AnalyticCEVEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdCEVVanillaEngine", _wrap_new_FdCEVVanillaEngine, METH_VARARGS, NULL},
	 { "delete_FdCEVVanillaEngine", _wrap_delete_FdCEVVanillaEngine, METH_O, NULL},
	 { "FdCEVVanillaEngine_swigregister", FdCEVVanillaEngine_swigregister, METH_O, NULL},
	 { "FdCEVVanillaEngine_swiginit", FdCEVVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdSabrVanillaEngine", _wrap_new_FdSabrVanillaEngine, METH_VARARGS, NULL},
	 { "delete_FdSabrVanillaEngine", _wrap_delete_FdSabrVanillaEngine, METH_O, NULL},
	 { "FdSabrVanillaEngine_swigregister", FdSabrVanillaEngine_swigregister, METH_O, NULL},
	 { "FdSabrVanillaEngine_swiginit", FdSabrVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesBarrierEngine", _wrap_new_FdBlackScholesBarrierEngine, METH_VARARGS, NULL},
	 { "delete_FdBlackScholesBarrierEngine", _wrap_delete_FdBlackScholesBarrierEngine, METH_O, NULL},
	 { "FdBlackScholesBarrierEngine_swigregister", FdBlackScholesBarrierEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesBarrierEngine_swiginit", FdBlackScholesBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesRebateEngine", _wrap_new_FdBlackScholesRebateEngine, METH_VARARGS, NULL},
	 { "delete_FdBlackScholesRebateEngine", _wrap_delete_FdBlackScholesRebateEngine, METH_O, NULL},
	 { "FdBlackScholesRebateEngine_swigregister", FdBlackScholesRebateEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesRebateEngine_swiginit", FdBlackScholesRebateEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonBarrierEngine", _wrap_new_FdHestonBarrierEngine, METH_VARARGS, NULL},
	 { "delete_FdHestonBarrierEngine", _wrap_delete_FdHestonBarrierEngine, METH_O, NULL},
	 { "FdHestonBarrierEngine_swigregister", FdHestonBarrierEngine_swigregister, METH_O, NULL},
	 { "FdHestonBarrierEngine_swiginit", FdHestonBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonRebateEngine", _wrap_new_FdHestonRebateEngine, METH_VARARGS, NULL},
	 { "delete_FdHestonRebateEngine", _wrap_delete_FdHestonRebateEngine, METH_O, NULL},
	 { "FdHestonRebateEngine_swigregister", FdHestonRebateEngine_swigregister, METH_O, NULL},
	 { "FdHestonRebateEngine_swiginit", FdHestonRebateEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticBinaryBarrierEngine", _wrap_new_AnalyticBinaryBarrierEngine, METH_O, NULL},
	 { "delete_AnalyticBinaryBarrierEngine", _wrap_delete_AnalyticBinaryBarrierEngine, METH_O, NULL},
	 { "AnalyticBinaryBarrierEngine_swigregister", AnalyticBinaryBarrierEngine_swigregister, METH_O, NULL},
	 { "AnalyticBinaryBarrierEngine_swiginit", AnalyticBinaryBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRBarrierEngine", _wrap_new_BinomialCRRBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialCRRBarrierEngine_swigregister", BinomialCRRBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRBarrierEngine_swiginit", BinomialCRRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRBarrierEngine", _wrap_new_BinomialJRBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialJRBarrierEngine_swigregister", BinomialJRBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJRBarrierEngine_swiginit", BinomialJRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPBarrierEngine", _wrap_new_BinomialEQPBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialEQPBarrierEngine_swigregister", BinomialEQPBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPBarrierEngine_swiginit", BinomialEQPBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisBarrierEngine", _wrap_new_BinomialTrigeorgisBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialTrigeorgisBarrierEngine_swigregister", BinomialTrigeorgisBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisBarrierEngine_swiginit", BinomialTrigeorgisBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianBarrierEngine", _wrap_new_BinomialTianBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialTianBarrierEngine_swigregister", BinomialTianBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTianBarrierEngine_swiginit", BinomialTianBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRBarrierEngine", _wrap_new_BinomialLRBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialLRBarrierEngine_swigregister", BinomialLRBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialLRBarrierEngine_swiginit", BinomialLRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4BarrierEngine", _wrap_new_BinomialJ4BarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialJ4BarrierEngine_swigregister", BinomialJ4BarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4BarrierEngine_swiginit", BinomialJ4BarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardEuropeanEngine", _wrap_new_ForwardEuropeanEngine, METH_O, NULL},
	 { "delete_ForwardEuropeanEngine", _wrap_delete_ForwardEuropeanEngine, METH_O, NULL},
	 { "ForwardEuropeanEngine_swigregister", ForwardEuropeanEngine_swigregister, METH_O, NULL},
	 { "ForwardEuropeanEngine_swiginit", ForwardEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoEuropeanEngine", _wrap_new_QuantoEuropeanEngine, METH_VARARGS, NULL},
	 { "delete_QuantoEuropeanEngine", _wrap_delete_QuantoEuropeanEngine, METH_O, NULL},
	 { "QuantoEuropeanEngine_swigregister", QuantoEuropeanEngine_swigregister, METH_O, NULL},
	 { "QuantoEuropeanEngine_swiginit", QuantoEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoForwardEuropeanEngine", _wrap_new_QuantoForwardEuropeanEngine, METH_VARARGS, NULL},
	 { "delete_QuantoForwardEuropeanEngine", _wrap_delete_QuantoForwardEuropeanEngine, METH_O, NULL},
	 { "QuantoForwardEuropeanEngine_swigregister", QuantoForwardEuropeanEngine_swigregister, METH_O, NULL},
	 { "QuantoForwardEuropeanEngine_swiginit", QuantoForwardEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCalculator", _wrap_new_BlackCalculator, METH_VARARGS, NULL},
	 { "BlackCalculator_value", _wrap_BlackCalculator_value, METH_O, NULL},
	 { "BlackCalculator_deltaForward", _wrap_BlackCalculator_deltaForward, METH_O, NULL},
	 { "BlackCalculator_delta", _wrap_BlackCalculator_delta, METH_VARARGS, NULL},
	 { "BlackCalculator_elasticityForward", _wrap_BlackCalculator_elasticityForward, METH_O, NULL},
	 { "BlackCalculator_elasticity", _wrap_BlackCalculator_elasticity, METH_VARARGS, NULL},
	 { "BlackCalculator_gammaForward", _wrap_BlackCalculator_gammaForward, METH_O, NULL},
	 { "BlackCalculator_gamma", _wrap_BlackCalculator_gamma, METH_VARARGS, NULL},
	 { "BlackCalculator_theta", _wrap_BlackCalculator_theta, METH_VARARGS, NULL},
	 { "BlackCalculator_thetaPerDay", _wrap_BlackCalculator_thetaPerDay, METH_VARARGS, NULL},
	 { "BlackCalculator_vega", _wrap_BlackCalculator_vega, METH_VARARGS, NULL},
	 { "BlackCalculator_rho", _wrap_BlackCalculator_rho, METH_VARARGS, NULL},
	 { "BlackCalculator_dividendRho", _wrap_BlackCalculator_dividendRho, METH_VARARGS, NULL},
	 { "BlackCalculator_itmCashProbability", _wrap_BlackCalculator_itmCashProbability, METH_O, NULL},
	 { "BlackCalculator_itmAssetProbability", _wrap_BlackCalculator_itmAssetProbability, METH_O, NULL},
	 { "BlackCalculator_strikeSensitivity", _wrap_BlackCalculator_strikeSensitivity, METH_O, NULL},
	 { "BlackCalculator_alpha", _wrap_BlackCalculator_alpha, METH_O, NULL},
	 { "BlackCalculator_beta", _wrap_BlackCalculator_beta, METH_O, NULL},
	 { "delete_BlackCalculator", _wrap_delete_BlackCalculator, METH_O, NULL},
	 { "BlackCalculator_swigregister", BlackCalculator_swigregister, METH_O, NULL},
	 { "BlackCalculator_swiginit", BlackCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_Average", _wrap_new_Average, METH_NOARGS, NULL},
	 { "delete_Average", _wrap_delete_Average, METH_O, NULL},
	 { "Average_swigregister", Average_swigregister, METH_O, NULL},
	 { "Average_swiginit", Average_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousAveragingAsianOption", _wrap_new_ContinuousAveragingAsianOption, METH_VARARGS, NULL},
	 { "delete_ContinuousAveragingAsianOption", _wrap_delete_ContinuousAveragingAsianOption, METH_O, NULL},
	 { "ContinuousAveragingAsianOption_swigregister", ContinuousAveragingAsianOption_swigregister, METH_O, NULL},
	 { "ContinuousAveragingAsianOption_swiginit", ContinuousAveragingAsianOption_swiginit, METH_VARARGS, NULL},
	 { "new_DiscreteAveragingAsianOption", _wrap_new_DiscreteAveragingAsianOption, METH_VARARGS, NULL},
	 { "delete_DiscreteAveragingAsianOption", _wrap_delete_DiscreteAveragingAsianOption, METH_O, NULL},
	 { "DiscreteAveragingAsianOption_swigregister", DiscreteAveragingAsianOption_swigregister, METH_O, NULL},
	 { "DiscreteAveragingAsianOption_swiginit", DiscreteAveragingAsianOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousGeometricAveragePriceAsianEngine", _wrap_new_AnalyticContinuousGeometricAveragePriceAsianEngine, METH_O, NULL},
	 { "delete_AnalyticContinuousGeometricAveragePriceAsianEngine", _wrap_delete_AnalyticContinuousGeometricAveragePriceAsianEngine, METH_O, NULL},
	 { "AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister", AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit", AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDiscreteGeometricAveragePriceAsianEngine", _wrap_new_AnalyticDiscreteGeometricAveragePriceAsianEngine, METH_O, NULL},
	 { "delete_AnalyticDiscreteGeometricAveragePriceAsianEngine", _wrap_delete_AnalyticDiscreteGeometricAveragePriceAsianEngine, METH_O, NULL},
	 { "AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister", AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister, METH_O, NULL},
	 { "AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit", AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDiscreteGeometricAverageStrikeAsianEngine", _wrap_new_AnalyticDiscreteGeometricAverageStrikeAsianEngine, METH_O, NULL},
	 { "delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine", _wrap_delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPRDiscreteArithmeticAPEngine", _wrap_delete_MCPRDiscreteArithmeticAPEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDDiscreteArithmeticAPEngine", _wrap_delete_MCLDDiscreteArithmeticAPEngine, METH_O, NULL},
	 { "MCLDDiscreteArithmeticAPEngine_swigregister", MCLDDiscreteArithmeticAPEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteArithmeticAPEngine_swiginit", MCLDDiscreteArithmeticAPEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDiscreteArithmeticASEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDiscreteArithmeticASEngine, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_MCPRDiscreteArithmeticASEngine", _wrap_delete_MCPRDiscreteArithmeticASEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDDiscreteArithmeticASEngine", _wrap_delete_MCLDDiscreteArithmeticASEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPRDiscreteGeometricAPEngine", _wrap_delete_MCPRDiscreteGeometricAPEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDDiscreteGeometricAPEngine", _wrap_delete_MCLDDiscreteGeometricAPEngine, METH_O, NULL},
	 { "MCLDDiscreteGeometricAPEngine_swigregister", MCLDDiscreteGeometricAPEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteGeometricAPEngine_swiginit", MCLDDiscreteGeometricAPEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VarianceGammaEngine", _wrap_new_VarianceGammaEngine, METH_O, NULL},
	 { "delete_VarianceGammaEngine", _wrap_delete_VarianceGammaEngine, METH_O, NULL},
	 { "VarianceGammaEngine_swigregister", VarianceGammaEngine_swigregister, METH_O, NULL},
	 { "VarianceGammaEngine_swiginit", VarianceGammaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FFTVarianceGammaEngine", _wrap_new_FFTVarianceGammaEngine, METH_VARARGS, NULL},
	 { "FFTVarianceGammaEngine_precalculate", _wrap_FFTVarianceGammaEngine_precalculate, METH_VARARGS, NULL},
	 { "delete_FFTVarianceGammaEngine", _wrap_delete_FFTVarianceGammaEngine, METH_O, NULL},
	 { "FFTVarianceGammaEngine_swigregister", FFTVarianceGammaEngine_swigregister, METH_O, NULL},
	 { "FFTVarianceGammaEngine_swiginit", FFTVarianceGammaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DoubleBarrierOption", _wrap_new_DoubleBarrierOption, METH_VARARGS, NULL},
	 { "delete_DoubleBarrierOption", _wrap_delete_DoubleBarrierOption, METH_O, NULL},
	 { "DoubleBarrierOption_swigregister", DoubleBarrierOption_swigregister, METH_O, NULL},
	 { "DoubleBarrierOption_swiginit", DoubleBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoDoubleBarrierOption", _wrap_new_QuantoDoubleBarrierOption, METH_VARARGS, NULL},
	 { "QuantoDoubleBarrierOption_qvega", _wrap_QuantoDoubleBarrierOption_qvega, METH_O, NULL},
	 { "QuantoDoubleBarrierOption_qrho", _wrap_QuantoDoubleBarrierOption_qrho, METH_O, NULL},
	 { "QuantoDoubleBarrierOption_qlambda", _wrap_QuantoDoubleBarrierOption_qlambda, METH_O, NULL},
	 { "delete_QuantoDoubleBarrierOption", _wrap_delete_QuantoDoubleBarrierOption, METH_O, NULL},
	 { "QuantoDoubleBarrierOption_swigregister", QuantoDoubleBarrierOption_swigregister, METH_O, NULL},
	 { "QuantoDoubleBarrierOption_swiginit", QuantoDoubleBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDoubleBarrierEngine", _wrap_new_AnalyticDoubleBarrierEngine, METH_VARARGS, "Double barrier engine implementing Ikeda-Kunitomo series."},
	 { "delete_AnalyticDoubleBarrierEngine", _wrap_delete_AnalyticDoubleBarrierEngine, METH_O, NULL},
	 { "AnalyticDoubleBarrierEngine_swigregister", AnalyticDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "AnalyticDoubleBarrierEngine_swiginit", AnalyticDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonDoubleBarrierEngine", _wrap_new_FdHestonDoubleBarrierEngine, METH_VARARGS, NULL},
	 { "delete_FdHestonDoubleBarrierEngine", _wrap_delete_FdHestonDoubleBarrierEngine, METH_O, NULL},
	 { "FdHestonDoubleBarrierEngine_swigregister", FdHestonDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "FdHestonDoubleBarrierEngine_swiginit", FdHestonDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_WulinYongDoubleBarrierEngine", _wrap_new_WulinYongDoubleBarrierEngine, METH_VARARGS, NULL},
	 { "delete_WulinYongDoubleBarrierEngine", _wrap_delete_WulinYongDoubleBarrierEngine, METH_O, NULL},
	 { "WulinYongDoubleBarrierEngine_swigregister", WulinYongDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "WulinYongDoubleBarrierEngine_swiginit", WulinYongDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DeltaVolQuote", _wrap_new_DeltaVolQuote, METH_VARARGS, NULL},
	 { "delete_DeltaVolQuote", _wrap_delete_DeltaVolQuote, METH_O, NULL},
	 { "DeltaVolQuote_swigregister", DeltaVolQuote_swigregister, METH_O, NULL},
	 { "DeltaVolQuote_swiginit", DeltaVolQuote_swiginit, METH_VARARGS, NULL},
	 { "new_DeltaVolQuoteHandle", _wrap_new_DeltaVolQuoteHandle, METH_VARARGS, NULL},
	 { "DeltaVolQuoteHandle___deref__", _wrap_DeltaVolQuoteHandle___deref__, METH_O, NULL},
	 { "DeltaVolQuoteHandle_currentLink", _wrap_DeltaVolQuoteHandle_currentLink, METH_O, NULL},
	 { "DeltaVolQuoteHandle___nonzero__", _wrap_DeltaVolQuoteHandle___nonzero__, METH_O, NULL},
	 { "DeltaVolQuoteHandle___bool__", _wrap_DeltaVolQuoteHandle___bool__, METH_O, NULL},
	 { "DeltaVolQuoteHandle_asObservable", _wrap_DeltaVolQuoteHandle_asObservable, METH_O, NULL},
	 { "delete_DeltaVolQuoteHandle", _wrap_delete_DeltaVolQuoteHandle, METH_O, NULL},
	 { "DeltaVolQuoteHandle_value", _wrap_DeltaVolQuoteHandle_value, METH_O, NULL},
	 { "DeltaVolQuoteHandle_isValid", _wrap_DeltaVolQuoteHandle_isValid, METH_O, NULL},
	 { "DeltaVolQuoteHandle_swigregister", DeltaVolQuoteHandle_swigregister, METH_O, NULL},
	 { "DeltaVolQuoteHandle_swiginit", DeltaVolQuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableDeltaVolQuoteHandle", _wrap_new_RelinkableDeltaVolQuoteHandle, METH_VARARGS, NULL},
	 { "RelinkableDeltaVolQuoteHandle_linkTo", _wrap_RelinkableDeltaVolQuoteHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableDeltaVolQuoteHandle_reset", _wrap_RelinkableDeltaVolQuoteHandle_reset, METH_O, NULL},
	 { "delete_RelinkableDeltaVolQuoteHandle", _wrap_delete_RelinkableDeltaVolQuoteHandle, METH_O, NULL},
	 { "RelinkableDeltaVolQuoteHandle_swigregister", RelinkableDeltaVolQuoteHandle_swigregister, METH_O, NULL},
	 { "RelinkableDeltaVolQuoteHandle_swiginit", RelinkableDeltaVolQuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_VannaVolgaIKDoubleBarrierEngine", _wrap_new_VannaVolgaIKDoubleBarrierEngine, METH_VARARGS, "\n"
		"\n"
		"Vanna-Volga engine for double barrier options.\n"
		"Supports different double barrier engines, selected by the type parameters.\n"
		"Type values:\n"
		"    ik or analytic:  Ikeda-Kunitomo standard engine (default)\n"
		"    wo:              Wulin-Yong engine\n"
		"\n"
		""},
	 { "delete_VannaVolgaIKDoubleBarrierEngine", _wrap_delete_VannaVolgaIKDoubleBarrierEngine, METH_O, NULL},
	 { "VannaVolgaIKDoubleBarrierEngine_swigregister", VannaVolgaIKDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "VannaVolgaIKDoubleBarrierEngine_swiginit", VannaVolgaIKDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VannaVolgaWODoubleBarrierEngine", _wrap_new_VannaVolgaWODoubleBarrierEngine, METH_VARARGS, "\n"
		"\n"
		"Vanna-Volga engine for double barrier options.\n"
		"Supports different double barrier engines, selected by the type parameters.\n"
		"Type values:\n"
		"    ik or analytic:  Ikeda-Kunitomo standard engine (default)\n"
		"    wo:              Wulin-Yong engine\n"
		"\n"
		""},
	 { "delete_VannaVolgaWODoubleBarrierEngine", _wrap_delete_VannaVolgaWODoubleBarrierEngine, METH_O, NULL},
	 { "VannaVolgaWODoubleBarrierEngine_swigregister", VannaVolgaWODoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "VannaVolgaWODoubleBarrierEngine_swiginit", VannaVolgaWODoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VannaVolgaBarrierEngine", _wrap_new_VannaVolgaBarrierEngine, METH_VARARGS, NULL},
	 { "delete_VannaVolgaBarrierEngine", _wrap_delete_VannaVolgaBarrierEngine, METH_O, NULL},
	 { "VannaVolgaBarrierEngine_swigregister", VannaVolgaBarrierEngine_swigregister, METH_O, NULL},
	 { "VannaVolgaBarrierEngine_swiginit", VannaVolgaBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDoubleBarrierBinaryEngine", _wrap_new_AnalyticDoubleBarrierBinaryEngine, METH_O, NULL},
	 { "delete_AnalyticDoubleBarrierBinaryEngine", _wrap_delete_AnalyticDoubleBarrierBinaryEngine, METH_O, NULL},
	 { "AnalyticDoubleBarrierBinaryEngine_swigregister", AnalyticDoubleBarrierBinaryEngine_swigregister, METH_O, NULL},
	 { "AnalyticDoubleBarrierBinaryEngine_swiginit", AnalyticDoubleBarrierBinaryEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRDoubleBarrierEngine", _wrap_new_BinomialCRRDoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialCRRDoubleBarrierEngine_swigregister", BinomialCRRDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRDoubleBarrierEngine_swiginit", BinomialCRRDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRDoubleBarrierEngine", _wrap_new_BinomialJRDoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialJRDoubleBarrierEngine_swigregister", BinomialJRDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJRDoubleBarrierEngine_swiginit", BinomialJRDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPDoubleBarrierEngine", _wrap_new_BinomialEQPDoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialEQPDoubleBarrierEngine_swigregister", BinomialEQPDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPDoubleBarrierEngine_swiginit", BinomialEQPDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisDoubleBarrierEngine", _wrap_new_BinomialTrigeorgisDoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialTrigeorgisDoubleBarrierEngine_swigregister", BinomialTrigeorgisDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisDoubleBarrierEngine_swiginit", BinomialTrigeorgisDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianDoubleBarrierEngine", _wrap_new_BinomialTianDoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialTianDoubleBarrierEngine_swigregister", BinomialTianDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTianDoubleBarrierEngine_swiginit", BinomialTianDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRDoubleBarrierEngine", _wrap_new_BinomialLRDoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialLRDoubleBarrierEngine_swigregister", BinomialLRDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialLRDoubleBarrierEngine_swiginit", BinomialLRDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4DoubleBarrierEngine", _wrap_new_BinomialJ4DoubleBarrierEngine, METH_VARARGS, "\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, NULL},
	 { "BinomialJ4DoubleBarrierEngine_swigregister", BinomialJ4DoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4DoubleBarrierEngine_swiginit", BinomialJ4DoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VanillaSwingOption", _wrap_new_VanillaSwingOption, METH_VARARGS, NULL},
	 { "delete_VanillaSwingOption", _wrap_delete_VanillaSwingOption, METH_O, NULL},
	 { "VanillaSwingOption_swigregister", VanillaSwingOption_swigregister, METH_O, NULL},
	 { "VanillaSwingOption_swiginit", VanillaSwingOption_swiginit, METH_VARARGS, NULL},
	 { "new_FdSimpleBSSwingEngine", _wrap_new_FdSimpleBSSwingEngine, METH_VARARGS, NULL},
	 { "delete_FdSimpleBSSwingEngine", _wrap_delete_FdSimpleBSSwingEngine, METH_O, NULL},
	 { "FdSimpleBSSwingEngine_swigregister", FdSimpleBSSwingEngine_swigregister, METH_O, NULL},
	 { "FdSimpleBSSwingEngine_swiginit", FdSimpleBSSwingEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdSimpleExtOUJumpSwingEngine", _wrap_new_FdSimpleExtOUJumpSwingEngine, METH_VARARGS, NULL},
	 { "delete_FdSimpleExtOUJumpSwingEngine", _wrap_delete_FdSimpleExtOUJumpSwingEngine, METH_O, NULL},
	 { "FdSimpleExtOUJumpSwingEngine_swigregister", FdSimpleExtOUJumpSwingEngine_swigregister, METH_O, NULL},
	 { "FdSimpleExtOUJumpSwingEngine_swiginit", FdSimpleExtOUJumpSwingEngine_swiginit, METH_VARARGS, NULL},
	 { "new_GJRGARCHModel", _wrap_new_GJRGARCHModel, METH_O, NULL},
	 { "GJRGARCHModel_omega", _wrap_GJRGARCHModel_omega, METH_O, NULL},
	 { "GJRGARCHModel_alpha", _wrap_GJRGARCHModel_alpha, METH_O, NULL},
	 { "GJRGARCHModel_beta", _wrap_GJRGARCHModel_beta, METH_O, NULL},
	 { "GJRGARCHModel_gamma", _wrap_GJRGARCHModel_gamma, METH_O, NULL},
	 { "GJRGARCHModel_lambda_parameter", _wrap_GJRGARCHModel_lambda_parameter, METH_O, NULL},
	 { "GJRGARCHModel_v0", _wrap_GJRGARCHModel_v0, METH_O, NULL},
	 { "delete_GJRGARCHModel", _wrap_delete_GJRGARCHModel, METH_O, NULL},
	 { "GJRGARCHModel_swigregister", GJRGARCHModel_swigregister, METH_O, NULL},
	 { "GJRGARCHModel_swiginit", GJRGARCHModel_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticGJRGARCHEngine", _wrap_new_AnalyticGJRGARCHEngine, METH_O, NULL},
	 { "delete_AnalyticGJRGARCHEngine", _wrap_delete_AnalyticGJRGARCHEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPREuropeanGJRGARCHEngine", _wrap_delete_MCPREuropeanGJRGARCHEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDEuropeanGJRGARCHEngine", _wrap_delete_MCLDEuropeanGJRGARCHEngine, METH_O, NULL},
	 { "MCLDEuropeanGJRGARCHEngine_swigregister", MCLDEuropeanGJRGARCHEngine_swigregister, METH_O, NULL},
	 { "MCLDEuropeanGJRGARCHEngine_swiginit", MCLDEuropeanGJRGARCHEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadOption", _wrap_new_SpreadOption, METH_VARARGS, NULL},
	 { "delete_SpreadOption", _wrap_delete_SpreadOption, METH_O, NULL},
	 { "SpreadOption_swigregister", SpreadOption_swigregister, METH_O, NULL},
	 { "SpreadOption_swiginit", SpreadOption_swiginit, METH_VARARGS, NULL},
	 { "new_KirkSpreadOptionEngine", _wrap_new_KirkSpreadOptionEngine, METH_VARARGS, NULL},
	 { "delete_KirkSpreadOptionEngine", _wrap_delete_KirkSpreadOptionEngine, METH_O, NULL},
	 { "KirkSpreadOptionEngine_swigregister", KirkSpreadOptionEngine_swigregister, METH_O, NULL},
	 { "KirkSpreadOptionEngine_swiginit", KirkSpreadOptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_PlainVanillaPayoff", _wrap_new_PlainVanillaPayoff, METH_VARARGS, NULL},
	 { "delete_PlainVanillaPayoff", _wrap_delete_PlainVanillaPayoff, METH_O, NULL},
	 { "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, NULL},
	 { "new_PercentageStrikePayoff", _wrap_new_PercentageStrikePayoff, METH_VARARGS, NULL},
	 { "delete_PercentageStrikePayoff", _wrap_delete_PercentageStrikePayoff, METH_O, NULL},
	 { "PercentageStrikePayoff_swigregister", PercentageStrikePayoff_swigregister, METH_O, NULL},
	 { "PercentageStrikePayoff_swiginit", PercentageStrikePayoff_swiginit, METH_VARARGS, NULL},
	 { "new_CashOrNothingPayoff", _wrap_new_CashOrNothingPayoff, METH_VARARGS, NULL},
	 { "delete_CashOrNothingPayoff", _wrap_delete_CashOrNothingPayoff, METH_O, NULL},
	 { "CashOrNothingPayoff_swigregister", CashOrNothingPayoff_swigregister, METH_O, NULL},
	 { "CashOrNothingPayoff_swiginit", CashOrNothingPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_AssetOrNothingPayoff", _wrap_new_AssetOrNothingPayoff, METH_VARARGS, NULL},
	 { "delete_AssetOrNothingPayoff", _wrap_delete_AssetOrNothingPayoff, METH_O, NULL},
	 { "AssetOrNothingPayoff_swigregister", AssetOrNothingPayoff_swigregister, METH_O, NULL},
	 { "AssetOrNothingPayoff_swiginit", AssetOrNothingPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_SuperSharePayoff", _wrap_new_SuperSharePayoff, METH_VARARGS, NULL},
	 { "delete_SuperSharePayoff", _wrap_delete_SuperSharePayoff, METH_O, NULL},
	 { "SuperSharePayoff_swigregister", SuperSharePayoff_swigregister, METH_O, NULL},
	 { "SuperSharePayoff_swiginit", SuperSharePayoff_swiginit, METH_VARARGS, NULL},
	 { "new_GapPayoff", _wrap_new_GapPayoff, METH_VARARGS, NULL},
	 { "delete_GapPayoff", _wrap_delete_GapPayoff, METH_O, NULL},
	 { "GapPayoff_swigregister", GapPayoff_swigregister, METH_O, NULL},
	 { "GapPayoff_swiginit", GapPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_VanillaForwardPayoff", _wrap_new_VanillaForwardPayoff, METH_VARARGS, NULL},
	 { "delete_VanillaForwardPayoff", _wrap_delete_VanillaForwardPayoff, METH_O, NULL},
	 { "VanillaForwardPayoff_swigregister", VanillaForwardPayoff_swigregister, METH_O, NULL},
	 { "VanillaForwardPayoff_swiginit", VanillaForwardPayoff_swiginit, METH_VARARGS, NULL},
	 { "delete_BasketPayoff", _wrap_delete_BasketPayoff, METH_O, NULL},
	 { "BasketPayoff_swigregister", BasketPayoff_swigregister, METH_O, NULL},
	 { "new_MinBasketPayoff", _wrap_new_MinBasketPayoff, METH_O, NULL},
	 { "delete_MinBasketPayoff", _wrap_delete_MinBasketPayoff, METH_O, NULL},
	 { "MinBasketPayoff_swigregister", MinBasketPayoff_swigregister, METH_O, NULL},
	 { "MinBasketPayoff_swiginit", MinBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_MaxBasketPayoff", _wrap_new_MaxBasketPayoff, METH_O, NULL},
	 { "delete_MaxBasketPayoff", _wrap_delete_MaxBasketPayoff, METH_O, NULL},
	 { "MaxBasketPayoff_swigregister", MaxBasketPayoff_swigregister, METH_O, NULL},
	 { "MaxBasketPayoff_swiginit", MaxBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_AverageBasketPayoff", _wrap_new_AverageBasketPayoff, METH_VARARGS, NULL},
	 { "delete_AverageBasketPayoff", _wrap_delete_AverageBasketPayoff, METH_O, NULL},
	 { "AverageBasketPayoff_swigregister", AverageBasketPayoff_swigregister, METH_O, NULL},
	 { "AverageBasketPayoff_swiginit", AverageBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadBasketPayoff", _wrap_new_SpreadBasketPayoff, METH_O, NULL},
	 { "delete_SpreadBasketPayoff", _wrap_delete_SpreadBasketPayoff, METH_O, NULL},
	 { "SpreadBasketPayoff_swigregister", SpreadBasketPayoff_swigregister, METH_O, NULL},
	 { "SpreadBasketPayoff_swiginit", SpreadBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_BasketOption", _wrap_new_BasketOption, METH_VARARGS, NULL},
	 { "delete_BasketOption", _wrap_delete_BasketOption, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPREuropeanBasketEngine", _wrap_delete_MCPREuropeanBasketEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDEuropeanBasketEngine", _wrap_delete_MCLDEuropeanBasketEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPRAmericanBasketEngine", _wrap_delete_MCPRAmericanBasketEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDAmericanBasketEngine", _wrap_delete_MCLDAmericanBasketEngine, METH_O, NULL},
	 { "MCLDAmericanBasketEngine_swigregister", MCLDAmericanBasketEngine_swigregister, METH_O, NULL},
	 { "MCLDAmericanBasketEngine_swiginit", MCLDAmericanBasketEngine_swiginit, METH_VARARGS, NULL},
	 { "new_StulzEngine", _wrap_new_StulzEngine, METH_VARARGS, NULL},
	 { "delete_StulzEngine", _wrap_delete_StulzEngine, METH_O, NULL},
	 { "StulzEngine_swigregister", StulzEngine_swigregister, METH_O, NULL},
	 { "StulzEngine_swiginit", StulzEngine_swiginit, METH_VARARGS, NULL},
	 { "new_KirkEngine", _wrap_new_KirkEngine, METH_VARARGS, NULL},
	 { "delete_KirkEngine", _wrap_delete_KirkEngine, METH_O, NULL},
	 { "KirkEngine_swigregister", KirkEngine_swigregister, METH_O, NULL},
	 { "KirkEngine_swiginit", KirkEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Fd2dBlackScholesVanillaEngine", _wrap_new_Fd2dBlackScholesVanillaEngine, METH_VARARGS, NULL},
	 { "delete_Fd2dBlackScholesVanillaEngine", _wrap_delete_Fd2dBlackScholesVanillaEngine, METH_O, NULL},
	 { "Fd2dBlackScholesVanillaEngine_swigregister", Fd2dBlackScholesVanillaEngine_swigregister, METH_O, NULL},
	 { "Fd2dBlackScholesVanillaEngine_swiginit", Fd2dBlackScholesVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_EverestOption", _wrap_new_EverestOption, METH_VARARGS, NULL},
	 { "delete_EverestOption", _wrap_delete_EverestOption, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPREverestEngine", _wrap_delete_MCPREverestEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDEverestEngine", _wrap_delete_MCLDEverestEngine, METH_O, NULL},
	 { "MCLDEverestEngine_swigregister", MCLDEverestEngine_swigregister, METH_O, NULL},
	 { "MCLDEverestEngine_swiginit", MCLDEverestEngine_swiginit, METH_VARARGS, NULL},
	 { "new_HimalayaOption", _wrap_new_HimalayaOption, METH_VARARGS, NULL},
	 { "delete_HimalayaOption", _wrap_delete_HimalayaOption, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCPRHimalayaEngine", _wrap_delete_MCPRHimalayaEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_MCLDHimalayaEngine", _wrap_delete_MCLDHimalayaEngine, METH_O, NULL},
	 { "MCLDHimalayaEngine_swigregister", MCLDHimalayaEngine_swigregister, METH_O, NULL},
	 { "MCLDHimalayaEngine_swiginit", MCLDHimalayaEngine_swiginit, METH_VARARGS, NULL},
	 { "blackFormula", _wrap_blackFormula, METH_VARARGS, NULL},
	 { "blackFormulaImpliedStdDev", _wrap_blackFormulaImpliedStdDev, METH_VARARGS, NULL},
	 { "blackFormulaImpliedStdDevLiRS", _wrap_blackFormulaImpliedStdDevLiRS, METH_VARARGS, NULL},
	 { "blackFormulaCashItmProbability", _wrap_blackFormulaCashItmProbability, METH_VARARGS, NULL},
	 { "blackFormulaAssetItmProbability", _wrap_blackFormulaAssetItmProbability, METH_VARARGS, NULL},
	 { "bachelierBlackFormula", _wrap_bachelierBlackFormula, METH_VARARGS, NULL},
	 { "bachelierBlackFormulaImpliedVol", _wrap_bachelierBlackFormulaImpliedVol, METH_VARARGS, NULL},
	 { "bachelierBlackFormulaAssetItmProbability", _wrap_bachelierBlackFormulaAssetItmProbability, METH_VARARGS, NULL},
	 { "new_BlackDeltaCalculator", _wrap_new_BlackDeltaCalculator, METH_VARARGS, NULL},
	 { "BlackDeltaCalculator_deltaFromStrike", _wrap_BlackDeltaCalculator_deltaFromStrike, METH_VARARGS, NULL},
	 { "BlackDeltaCalculator_strikeFromDelta", _wrap_BlackDeltaCalculator_strikeFromDelta, METH_VARARGS, NULL},
	 { "BlackDeltaCalculator_atmStrike", _wrap_BlackDeltaCalculator_atmStrike, METH_VARARGS, NULL},
	 { "delete_BlackDeltaCalculator", _wrap_delete_BlackDeltaCalculator, METH_O, NULL},
	 { "BlackDeltaCalculator_swigregister", BlackDeltaCalculator_swigregister, METH_O, NULL},
	 { "BlackDeltaCalculator_swiginit", BlackDeltaCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_CallabilityPrice", _wrap_new_CallabilityPrice, METH_VARARGS, NULL},
	 { "CallabilityPrice_amount", _wrap_CallabilityPrice_amount, METH_O, NULL},
	 { "CallabilityPrice_type", _wrap_CallabilityPrice_type, METH_O, NULL},
	 { "delete_CallabilityPrice", _wrap_delete_CallabilityPrice, METH_O, NULL},
	 { "CallabilityPrice_swigregister", CallabilityPrice_swigregister, METH_O, NULL},
	 { "CallabilityPrice_swiginit", CallabilityPrice_swiginit, METH_VARARGS, NULL},
	 { "new_Callability", _wrap_new_Callability, METH_VARARGS, NULL},
	 { "Callability_price", _wrap_Callability_price, METH_O, NULL},
	 { "Callability_type", _wrap_Callability_type, METH_O, NULL},
	 { "Callability_date", _wrap_Callability_date, METH_O, NULL},
	 { "delete_Callability", _wrap_delete_Callability, METH_O, NULL},
	 { "Callability_swigregister", Callability_swigregister, METH_O, NULL},
	 { "Callability_swiginit", Callability_swiginit, METH_VARARGS, NULL},
	 { "new_SoftCallability", _wrap_new_SoftCallability, METH_VARARGS, NULL},
	 { "delete_SoftCallability", _wrap_delete_SoftCallability, METH_O, NULL},
	 { "SoftCallability_swigregister", SoftCallability_swigregister, METH_O, NULL},
	 { "SoftCallability_swiginit", SoftCallability_swiginit, METH_VARARGS, NULL},
	 { "CallabilitySchedule_iterator", _wrap_CallabilitySchedule_iterator, METH_O, NULL},
	 { "CallabilitySchedule___nonzero__", _wrap_CallabilitySchedule___nonzero__, METH_O, NULL},
	 { "CallabilitySchedule___bool__", _wrap_CallabilitySchedule___bool__, METH_O, NULL},
	 { "CallabilitySchedule___len__", _wrap_CallabilitySchedule___len__, METH_O, NULL},
	 { "CallabilitySchedule___getslice__", _wrap_CallabilitySchedule___getslice__, METH_VARARGS, NULL},
	 { "CallabilitySchedule___setslice__", _wrap_CallabilitySchedule___setslice__, METH_VARARGS, NULL},
	 { "CallabilitySchedule___delslice__", _wrap_CallabilitySchedule___delslice__, METH_VARARGS, NULL},
	 { "CallabilitySchedule___delitem__", _wrap_CallabilitySchedule___delitem__, METH_VARARGS, NULL},
	 { "CallabilitySchedule___getitem__", _wrap_CallabilitySchedule___getitem__, METH_VARARGS, NULL},
	 { "CallabilitySchedule___setitem__", _wrap_CallabilitySchedule___setitem__, METH_VARARGS, NULL},
	 { "CallabilitySchedule_pop", _wrap_CallabilitySchedule_pop, METH_O, NULL},
	 { "CallabilitySchedule_append", _wrap_CallabilitySchedule_append, METH_VARARGS, NULL},
	 { "CallabilitySchedule_empty", _wrap_CallabilitySchedule_empty, METH_O, NULL},
	 { "CallabilitySchedule_size", _wrap_CallabilitySchedule_size, METH_O, NULL},
	 { "CallabilitySchedule_swap", _wrap_CallabilitySchedule_swap, METH_VARARGS, NULL},
	 { "CallabilitySchedule_begin", _wrap_CallabilitySchedule_begin, METH_O, NULL},
	 { "CallabilitySchedule_end", _wrap_CallabilitySchedule_end, METH_O, NULL},
	 { "CallabilitySchedule_rbegin", _wrap_CallabilitySchedule_rbegin, METH_O, NULL},
	 { "CallabilitySchedule_rend", _wrap_CallabilitySchedule_rend, METH_O, NULL},
	 { "CallabilitySchedule_clear", _wrap_CallabilitySchedule_clear, METH_O, NULL},
	 { "CallabilitySchedule_get_allocator", _wrap_CallabilitySchedule_get_allocator, METH_O, NULL},
	 { "CallabilitySchedule_pop_back", _wrap_CallabilitySchedule_pop_back, METH_O, NULL},
	 { "CallabilitySchedule_erase", _wrap_CallabilitySchedule_erase, METH_VARARGS, NULL},
	 { "new_CallabilitySchedule", _wrap_new_CallabilitySchedule, METH_VARARGS, NULL},
	 { "CallabilitySchedule_push_back", _wrap_CallabilitySchedule_push_back, METH_VARARGS, NULL},
	 { "CallabilitySchedule_front", _wrap_CallabilitySchedule_front, METH_O, NULL},
	 { "CallabilitySchedule_back", _wrap_CallabilitySchedule_back, METH_O, NULL},
	 { "CallabilitySchedule_assign", _wrap_CallabilitySchedule_assign, METH_VARARGS, NULL},
	 { "CallabilitySchedule_resize", _wrap_CallabilitySchedule_resize, METH_VARARGS, NULL},
	 { "CallabilitySchedule_insert", _wrap_CallabilitySchedule_insert, METH_VARARGS, NULL},
	 { "CallabilitySchedule_reserve", _wrap_CallabilitySchedule_reserve, METH_VARARGS, NULL},
	 { "CallabilitySchedule_capacity", _wrap_CallabilitySchedule_capacity, METH_O, NULL},
	 { "delete_CallabilitySchedule", _wrap_delete_CallabilitySchedule, METH_O, NULL},
	 { "CallabilitySchedule_swigregister", CallabilitySchedule_swigregister, METH_O, NULL},
	 { "CallabilitySchedule_swiginit", CallabilitySchedule_swiginit, METH_VARARGS, NULL},
	 { "new_TimeBasket", _wrap_new_TimeBasket, METH_VARARGS, NULL},
	 { "TimeBasket___len__", _wrap_TimeBasket___len__, METH_O, NULL},
	 { "TimeBasket_rebin", _wrap_TimeBasket_rebin, METH_VARARGS, NULL},
	 { "TimeBasket___getitem__", _wrap_TimeBasket___getitem__, METH_VARARGS, NULL},
	 { "TimeBasket___setitem__", _wrap_TimeBasket___setitem__, METH_VARARGS, NULL},
	 { "TimeBasket_items", _wrap_TimeBasket_items, METH_O, NULL},
	 { "TimeBasket___contains__", _wrap_TimeBasket___contains__, METH_VARARGS, NULL},
	 { "TimeBasket___iter__", _wrap_TimeBasket___iter__, METH_O, NULL},
	 { "delete_TimeBasket", _wrap_delete_TimeBasket, METH_O, NULL},
	 { "TimeBasket_swigregister", TimeBasket_swigregister, METH_O, NULL},
	 { "TimeBasket_swiginit", TimeBasket_swiginit, METH_VARARGS, NULL},
	 { "new_Swap", _wrap_new_Swap, METH_VARARGS, NULL},
	 { "Swap_startDate", _wrap_Swap_startDate, METH_O, NULL},
	 { "Swap_maturityDate", _wrap_Swap_maturityDate, METH_O, NULL},
	 { "Swap_leg", _wrap_Swap_leg, METH_VARARGS, NULL},
	 { "Swap_legNPV", _wrap_Swap_legNPV, METH_VARARGS, NULL},
	 { "Swap_legBPS", _wrap_Swap_legBPS, METH_VARARGS, NULL},
	 { "delete_Swap", _wrap_delete_Swap, METH_O, NULL},
	 { "Swap_swigregister", Swap_swigregister, METH_O, NULL},
	 { "Swap_swiginit", Swap_swiginit, METH_VARARGS, NULL},
	 { "new_VanillaSwap", _wrap_new_VanillaSwap, METH_VARARGS, NULL},
	 { "VanillaSwap_fairRate", _wrap_VanillaSwap_fairRate, METH_O, NULL},
	 { "VanillaSwap_fairSpread", _wrap_VanillaSwap_fairSpread, METH_O, NULL},
	 { "VanillaSwap_fixedLegBPS", _wrap_VanillaSwap_fixedLegBPS, METH_O, NULL},
	 { "VanillaSwap_floatingLegBPS", _wrap_VanillaSwap_floatingLegBPS, METH_O, NULL},
	 { "VanillaSwap_fixedLegNPV", _wrap_VanillaSwap_fixedLegNPV, METH_O, NULL},
	 { "VanillaSwap_floatingLegNPV", _wrap_VanillaSwap_floatingLegNPV, METH_O, NULL},
	 { "VanillaSwap_fixedLeg", _wrap_VanillaSwap_fixedLeg, METH_O, NULL},
	 { "VanillaSwap_floatingLeg", _wrap_VanillaSwap_floatingLeg, METH_O, NULL},
	 { "VanillaSwap_nominal", _wrap_VanillaSwap_nominal, METH_O, NULL},
	 { "VanillaSwap_fixedSchedule", _wrap_VanillaSwap_fixedSchedule, METH_O, NULL},
	 { "VanillaSwap_floatingSchedule", _wrap_VanillaSwap_floatingSchedule, METH_O, NULL},
	 { "VanillaSwap_fixedRate", _wrap_VanillaSwap_fixedRate, METH_O, NULL},
	 { "VanillaSwap_spread", _wrap_VanillaSwap_spread, METH_O, NULL},
	 { "VanillaSwap_floatingDayCount", _wrap_VanillaSwap_floatingDayCount, METH_O, NULL},
	 { "VanillaSwap_fixedDayCount", _wrap_VanillaSwap_fixedDayCount, METH_O, NULL},
	 { "delete_VanillaSwap", _wrap_delete_VanillaSwap, METH_O, NULL},
	 { "VanillaSwap_swigregister", VanillaSwap_swigregister, METH_O, NULL},
	 { "VanillaSwap_swiginit", VanillaSwap_swiginit, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_receiveFixed", _wrap__MakeVanillaSwap_receiveFixed, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withType", _wrap__MakeVanillaSwap_withType, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withNominal", _wrap__MakeVanillaSwap_withNominal, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withSettlementDays", _wrap__MakeVanillaSwap_withSettlementDays, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withEffectiveDate", _wrap__MakeVanillaSwap_withEffectiveDate, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withTerminationDate", _wrap__MakeVanillaSwap_withTerminationDate, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withRule", _wrap__MakeVanillaSwap_withRule, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegTenor", _wrap__MakeVanillaSwap_withFixedLegTenor, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegCalendar", _wrap__MakeVanillaSwap_withFixedLegCalendar, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegConvention", _wrap__MakeVanillaSwap_withFixedLegConvention, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegTerminationDateConvention", _wrap__MakeVanillaSwap_withFixedLegTerminationDateConvention, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegRule", _wrap__MakeVanillaSwap_withFixedLegRule, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegEndOfMonth", _wrap__MakeVanillaSwap_withFixedLegEndOfMonth, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegFirstDate", _wrap__MakeVanillaSwap_withFixedLegFirstDate, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegNextToLastDate", _wrap__MakeVanillaSwap_withFixedLegNextToLastDate, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFixedLegDayCount", _wrap__MakeVanillaSwap_withFixedLegDayCount, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegTenor", _wrap__MakeVanillaSwap_withFloatingLegTenor, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegCalendar", _wrap__MakeVanillaSwap_withFloatingLegCalendar, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegConvention", _wrap__MakeVanillaSwap_withFloatingLegConvention, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegTerminationDateConvention", _wrap__MakeVanillaSwap_withFloatingLegTerminationDateConvention, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegRule", _wrap__MakeVanillaSwap_withFloatingLegRule, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegEndOfMonth", _wrap__MakeVanillaSwap_withFloatingLegEndOfMonth, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegFirstDate", _wrap__MakeVanillaSwap_withFloatingLegFirstDate, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegNextToLastDate", _wrap__MakeVanillaSwap_withFloatingLegNextToLastDate, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegDayCount", _wrap__MakeVanillaSwap_withFloatingLegDayCount, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withFloatingLegSpread", _wrap__MakeVanillaSwap_withFloatingLegSpread, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withDiscountingTermStructure", _wrap__MakeVanillaSwap_withDiscountingTermStructure, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_withPricingEngine", _wrap__MakeVanillaSwap_withPricingEngine, METH_VARARGS, NULL},
	 { "new__MakeVanillaSwap", _wrap_new__MakeVanillaSwap, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_makeVanillaSwap", _wrap__MakeVanillaSwap_makeVanillaSwap, METH_O, NULL},
	 { "delete__MakeVanillaSwap", _wrap_delete__MakeVanillaSwap, METH_O, NULL},
	 { "_MakeVanillaSwap_swigregister", _MakeVanillaSwap_swigregister, METH_O, NULL},
	 { "_MakeVanillaSwap_swiginit", _MakeVanillaSwap_swiginit, METH_VARARGS, NULL},
	 { "new_NonstandardSwap", _wrap_new_NonstandardSwap, METH_VARARGS, NULL},
	 { "NonstandardSwap_type", _wrap_NonstandardSwap_type, METH_O, NULL},
	 { "NonstandardSwap_fixedNominal", _wrap_NonstandardSwap_fixedNominal, METH_O, NULL},
	 { "NonstandardSwap_floatingNominal", _wrap_NonstandardSwap_floatingNominal, METH_O, NULL},
	 { "NonstandardSwap_fixedSchedule", _wrap_NonstandardSwap_fixedSchedule, METH_O, NULL},
	 { "NonstandardSwap_fixedRate", _wrap_NonstandardSwap_fixedRate, METH_O, NULL},
	 { "NonstandardSwap_fixedDayCount", _wrap_NonstandardSwap_fixedDayCount, METH_O, NULL},
	 { "NonstandardSwap_floatingSchedule", _wrap_NonstandardSwap_floatingSchedule, METH_O, NULL},
	 { "NonstandardSwap_iborIndex", _wrap_NonstandardSwap_iborIndex, METH_O, NULL},
	 { "NonstandardSwap_spread", _wrap_NonstandardSwap_spread, METH_O, NULL},
	 { "NonstandardSwap_gearing", _wrap_NonstandardSwap_gearing, METH_O, NULL},
	 { "NonstandardSwap_spreads", _wrap_NonstandardSwap_spreads, METH_O, NULL},
	 { "NonstandardSwap_gearings", _wrap_NonstandardSwap_gearings, METH_O, NULL},
	 { "NonstandardSwap_floatingDayCount", _wrap_NonstandardSwap_floatingDayCount, METH_O, NULL},
	 { "NonstandardSwap_paymentConvention", _wrap_NonstandardSwap_paymentConvention, METH_O, NULL},
	 { "NonstandardSwap_fixedLeg", _wrap_NonstandardSwap_fixedLeg, METH_O, NULL},
	 { "NonstandardSwap_floatingLeg", _wrap_NonstandardSwap_floatingLeg, METH_O, NULL},
	 { "delete_NonstandardSwap", _wrap_delete_NonstandardSwap, METH_O, NULL},
	 { "NonstandardSwap_swigregister", NonstandardSwap_swigregister, METH_O, NULL},
	 { "NonstandardSwap_swiginit", NonstandardSwap_swiginit, METH_VARARGS, NULL},
	 { "new_DiscountingSwapEngine", _wrap_new_DiscountingSwapEngine, METH_VARARGS, NULL},
	 { "delete_DiscountingSwapEngine", _wrap_delete_DiscountingSwapEngine, METH_O, NULL},
	 { "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, NULL},
	 { "AssetSwap_fairCleanPrice", _wrap_AssetSwap_fairCleanPrice, METH_O, NULL},
	 { "AssetSwap_fairSpread", _wrap_AssetSwap_fairSpread, METH_O, NULL},
	 { "delete_AssetSwap", _wrap_delete_AssetSwap, METH_O, NULL},
	 { "AssetSwap_swigregister", AssetSwap_swigregister, METH_O, NULL},
	 { "AssetSwap_swiginit", AssetSwap_swiginit, METH_VARARGS, NULL},
	 { "new_FloatFloatSwap", _wrap_new_FloatFloatSwap, METH_VARARGS, NULL},
	 { "delete_FloatFloatSwap", _wrap_delete_FloatFloatSwap, METH_O, NULL},
	 { "FloatFloatSwap_swigregister", FloatFloatSwap_swigregister, METH_O, NULL},
	 { "FloatFloatSwap_swiginit", FloatFloatSwap_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexedSwap", _wrap_new_OvernightIndexedSwap, METH_VARARGS, NULL},
	 { "OvernightIndexedSwap_fixedLegBPS", _wrap_OvernightIndexedSwap_fixedLegBPS, METH_O, NULL},
	 { "OvernightIndexedSwap_fixedLegNPV", _wrap_OvernightIndexedSwap_fixedLegNPV, METH_O, NULL},
	 { "OvernightIndexedSwap_fairRate", _wrap_OvernightIndexedSwap_fairRate, METH_O, NULL},
	 { "OvernightIndexedSwap_overnightLegBPS", _wrap_OvernightIndexedSwap_overnightLegBPS, METH_O, NULL},
	 { "OvernightIndexedSwap_overnightLegNPV", _wrap_OvernightIndexedSwap_overnightLegNPV, METH_O, NULL},
	 { "OvernightIndexedSwap_fairSpread", _wrap_OvernightIndexedSwap_fairSpread, METH_O, NULL},
	 { "OvernightIndexedSwap_type", _wrap_OvernightIndexedSwap_type, METH_O, NULL},
	 { "OvernightIndexedSwap_nominal", _wrap_OvernightIndexedSwap_nominal, METH_O, NULL},
	 { "OvernightIndexedSwap_nominals", _wrap_OvernightIndexedSwap_nominals, METH_O, NULL},
	 { "OvernightIndexedSwap_paymentFrequency", _wrap_OvernightIndexedSwap_paymentFrequency, METH_O, NULL},
	 { "OvernightIndexedSwap_fixedRate", _wrap_OvernightIndexedSwap_fixedRate, METH_O, NULL},
	 { "OvernightIndexedSwap_fixedDayCount", _wrap_OvernightIndexedSwap_fixedDayCount, METH_O, NULL},
	 { "OvernightIndexedSwap_spread", _wrap_OvernightIndexedSwap_spread, METH_O, NULL},
	 { "OvernightIndexedSwap_fixedLeg", _wrap_OvernightIndexedSwap_fixedLeg, METH_O, NULL},
	 { "OvernightIndexedSwap_overnightLeg", _wrap_OvernightIndexedSwap_overnightLeg, METH_O, NULL},
	 { "delete_OvernightIndexedSwap", _wrap_delete_OvernightIndexedSwap, METH_O, NULL},
	 { "OvernightIndexedSwap_swigregister", OvernightIndexedSwap_swigregister, METH_O, NULL},
	 { "OvernightIndexedSwap_swiginit", OvernightIndexedSwap_swiginit, METH_VARARGS, NULL},
	 { "new__MakeOIS", _wrap_new__MakeOIS, METH_VARARGS, NULL},
	 { "_MakeOIS_makeOIS", _wrap__MakeOIS_makeOIS, METH_O, NULL},
	 { "_MakeOIS_receiveFixed", _wrap__MakeOIS_receiveFixed, METH_VARARGS, NULL},
	 { "_MakeOIS_withType", _wrap__MakeOIS_withType, METH_VARARGS, NULL},
	 { "_MakeOIS_withNominal", _wrap__MakeOIS_withNominal, METH_VARARGS, NULL},
	 { "_MakeOIS_withSettlementDays", _wrap__MakeOIS_withSettlementDays, METH_VARARGS, NULL},
	 { "_MakeOIS_withEffectiveDate", _wrap__MakeOIS_withEffectiveDate, METH_VARARGS, NULL},
	 { "_MakeOIS_withTerminationDate", _wrap__MakeOIS_withTerminationDate, METH_VARARGS, NULL},
	 { "_MakeOIS_withRule", _wrap__MakeOIS_withRule, METH_VARARGS, NULL},
	 { "_MakeOIS_withPaymentFrequency", _wrap__MakeOIS_withPaymentFrequency, METH_VARARGS, NULL},
	 { "_MakeOIS_withPaymentAdjustment", _wrap__MakeOIS_withPaymentAdjustment, METH_VARARGS, NULL},
	 { "_MakeOIS_withPaymentLag", _wrap__MakeOIS_withPaymentLag, METH_VARARGS, NULL},
	 { "_MakeOIS_withPaymentCalendar", _wrap__MakeOIS_withPaymentCalendar, METH_VARARGS, NULL},
	 { "_MakeOIS_withEndOfMonth", _wrap__MakeOIS_withEndOfMonth, METH_VARARGS, NULL},
	 { "_MakeOIS_withFixedLegDayCount", _wrap__MakeOIS_withFixedLegDayCount, METH_VARARGS, NULL},
	 { "_MakeOIS_withOvernightLegSpread", _wrap__MakeOIS_withOvernightLegSpread, METH_VARARGS, NULL},
	 { "_MakeOIS_withDiscountingTermStructure", _wrap__MakeOIS_withDiscountingTermStructure, METH_VARARGS, NULL},
	 { "_MakeOIS_withTelescopicValueDates", _wrap__MakeOIS_withTelescopicValueDates, METH_VARARGS, NULL},
	 { "_MakeOIS_withPricingEngine", _wrap__MakeOIS_withPricingEngine, METH_VARARGS, NULL},
	 { "delete__MakeOIS", _wrap_delete__MakeOIS, METH_O, NULL},
	 { "_MakeOIS_swigregister", _MakeOIS_swigregister, METH_O, NULL},
	 { "_MakeOIS_swiginit", _MakeOIS_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexedSwapIndex", _wrap_new_OvernightIndexedSwapIndex, METH_VARARGS, NULL},
	 { "OvernightIndexedSwapIndex_overnightIndex", _wrap_OvernightIndexedSwapIndex_overnightIndex, METH_O, NULL},
	 { "OvernightIndexedSwapIndex_underlyingSwap", _wrap_OvernightIndexedSwapIndex_underlyingSwap, METH_VARARGS, NULL},
	 { "delete_OvernightIndexedSwapIndex", _wrap_delete_OvernightIndexedSwapIndex, METH_O, NULL},
	 { "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, NULL},
	 { "Seasonality_correctZeroRate", _wrap_Seasonality_correctZeroRate, METH_VARARGS, NULL},
	 { "Seasonality_correctYoYRate", _wrap_Seasonality_correctYoYRate, METH_VARARGS, NULL},
	 { "Seasonality_isConsistent", _wrap_Seasonality_isConsistent, METH_VARARGS, NULL},
	 { "delete_Seasonality", _wrap_delete_Seasonality, METH_O, NULL},
	 { "Seasonality_swigregister", Seasonality_swigregister, METH_O, NULL},
	 { "new_MultiplicativePriceSeasonality", _wrap_new_MultiplicativePriceSeasonality, METH_VARARGS, NULL},
	 { "delete_MultiplicativePriceSeasonality", _wrap_delete_MultiplicativePriceSeasonality, METH_O, NULL},
	 { "MultiplicativePriceSeasonality_swigregister", MultiplicativePriceSeasonality_swigregister, METH_O, NULL},
	 { "MultiplicativePriceSeasonality_swiginit", MultiplicativePriceSeasonality_swiginit, METH_VARARGS, NULL},
	 { "new_KerkhofSeasonality", _wrap_new_KerkhofSeasonality, METH_VARARGS, NULL},
	 { "delete_KerkhofSeasonality", _wrap_delete_KerkhofSeasonality, METH_O, NULL},
	 { "KerkhofSeasonality_swigregister", KerkhofSeasonality_swigregister, METH_O, NULL},
	 { "KerkhofSeasonality_swiginit", KerkhofSeasonality_swiginit, METH_VARARGS, NULL},
	 { "InflationTermStructure_observationLag", _wrap_InflationTermStructure_observationLag, METH_O, NULL},
	 { "InflationTermStructure_frequency", _wrap_InflationTermStructure_frequency, METH_O, NULL},
	 { "InflationTermStructure_indexIsInterpolated", _wrap_InflationTermStructure_indexIsInterpolated, METH_O, NULL},
	 { "InflationTermStructure_baseRate", _wrap_InflationTermStructure_baseRate, METH_O, NULL},
	 { "InflationTermStructure_nominalTermStructure", _wrap_InflationTermStructure_nominalTermStructure, METH_O, NULL},
	 { "InflationTermStructure_baseDate", _wrap_InflationTermStructure_baseDate, METH_O, NULL},
	 { "InflationTermStructure_setSeasonality", _wrap_InflationTermStructure_setSeasonality, METH_VARARGS, NULL},
	 { "InflationTermStructure_seasonality", _wrap_InflationTermStructure_seasonality, METH_O, NULL},
	 { "InflationTermStructure_hasSeasonality", _wrap_InflationTermStructure_hasSeasonality, METH_O, NULL},
	 { "delete_InflationTermStructure", _wrap_delete_InflationTermStructure, METH_O, NULL},
	 { "InflationTermStructure_swigregister", InflationTermStructure_swigregister, METH_O, NULL},
	 { "YoYInflationTermStructure_yoyRate", _wrap_YoYInflationTermStructure_yoyRate, METH_VARARGS, NULL},
	 { "delete_YoYInflationTermStructure", _wrap_delete_YoYInflationTermStructure, METH_O, NULL},
	 { "YoYInflationTermStructure_swigregister", YoYInflationTermStructure_swigregister, METH_O, NULL},
	 { "new_YoYInflationTermStructureHandle", _wrap_new_YoYInflationTermStructureHandle, METH_VARARGS, NULL},
	 { "YoYInflationTermStructureHandle___deref__", _wrap_YoYInflationTermStructureHandle___deref__, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_currentLink", _wrap_YoYInflationTermStructureHandle_currentLink, METH_O, NULL},
	 { "YoYInflationTermStructureHandle___nonzero__", _wrap_YoYInflationTermStructureHandle___nonzero__, METH_O, NULL},
	 { "YoYInflationTermStructureHandle___bool__", _wrap_YoYInflationTermStructureHandle___bool__, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_asObservable", _wrap_YoYInflationTermStructureHandle_asObservable, METH_O, NULL},
	 { "delete_YoYInflationTermStructureHandle", _wrap_delete_YoYInflationTermStructureHandle, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_yoyRate", _wrap_YoYInflationTermStructureHandle_yoyRate, METH_VARARGS, NULL},
	 { "YoYInflationTermStructureHandle_observationLag", _wrap_YoYInflationTermStructureHandle_observationLag, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_frequency", _wrap_YoYInflationTermStructureHandle_frequency, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_indexIsInterpolated", _wrap_YoYInflationTermStructureHandle_indexIsInterpolated, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_baseRate", _wrap_YoYInflationTermStructureHandle_baseRate, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_nominalTermStructure", _wrap_YoYInflationTermStructureHandle_nominalTermStructure, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_baseDate", _wrap_YoYInflationTermStructureHandle_baseDate, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_setSeasonality", _wrap_YoYInflationTermStructureHandle_setSeasonality, METH_VARARGS, NULL},
	 { "YoYInflationTermStructureHandle_seasonality", _wrap_YoYInflationTermStructureHandle_seasonality, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_hasSeasonality", _wrap_YoYInflationTermStructureHandle_hasSeasonality, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_dayCounter", _wrap_YoYInflationTermStructureHandle_dayCounter, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_timeFromReference", _wrap_YoYInflationTermStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "YoYInflationTermStructureHandle_calendar", _wrap_YoYInflationTermStructureHandle_calendar, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_referenceDate", _wrap_YoYInflationTermStructureHandle_referenceDate, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_maxDate", _wrap_YoYInflationTermStructureHandle_maxDate, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_maxTime", _wrap_YoYInflationTermStructureHandle_maxTime, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_enableExtrapolation", _wrap_YoYInflationTermStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_disableExtrapolation", _wrap_YoYInflationTermStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_allowsExtrapolation", _wrap_YoYInflationTermStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_swigregister", YoYInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_swiginit", YoYInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableYoYInflationTermStructureHandle", _wrap_new_RelinkableYoYInflationTermStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableYoYInflationTermStructureHandle_linkTo", _wrap_RelinkableYoYInflationTermStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableYoYInflationTermStructureHandle_reset", _wrap_RelinkableYoYInflationTermStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableYoYInflationTermStructureHandle", _wrap_delete_RelinkableYoYInflationTermStructureHandle, METH_O, NULL},
	 { "RelinkableYoYInflationTermStructureHandle_swigregister", RelinkableYoYInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableYoYInflationTermStructureHandle_swiginit", RelinkableYoYInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "ZeroInflationTermStructure_zeroRate", _wrap_ZeroInflationTermStructure_zeroRate, METH_VARARGS, NULL},
	 { "delete_ZeroInflationTermStructure", _wrap_delete_ZeroInflationTermStructure, METH_O, NULL},
	 { "ZeroInflationTermStructure_swigregister", ZeroInflationTermStructure_swigregister, METH_O, NULL},
	 { "new_ZeroInflationTermStructureHandle", _wrap_new_ZeroInflationTermStructureHandle, METH_VARARGS, NULL},
	 { "ZeroInflationTermStructureHandle___deref__", _wrap_ZeroInflationTermStructureHandle___deref__, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_currentLink", _wrap_ZeroInflationTermStructureHandle_currentLink, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle___nonzero__", _wrap_ZeroInflationTermStructureHandle___nonzero__, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle___bool__", _wrap_ZeroInflationTermStructureHandle___bool__, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_asObservable", _wrap_ZeroInflationTermStructureHandle_asObservable, METH_O, NULL},
	 { "delete_ZeroInflationTermStructureHandle", _wrap_delete_ZeroInflationTermStructureHandle, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_zeroRate", _wrap_ZeroInflationTermStructureHandle_zeroRate, METH_VARARGS, NULL},
	 { "ZeroInflationTermStructureHandle_observationLag", _wrap_ZeroInflationTermStructureHandle_observationLag, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_frequency", _wrap_ZeroInflationTermStructureHandle_frequency, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_indexIsInterpolated", _wrap_ZeroInflationTermStructureHandle_indexIsInterpolated, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_baseRate", _wrap_ZeroInflationTermStructureHandle_baseRate, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_nominalTermStructure", _wrap_ZeroInflationTermStructureHandle_nominalTermStructure, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_baseDate", _wrap_ZeroInflationTermStructureHandle_baseDate, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_setSeasonality", _wrap_ZeroInflationTermStructureHandle_setSeasonality, METH_VARARGS, NULL},
	 { "ZeroInflationTermStructureHandle_seasonality", _wrap_ZeroInflationTermStructureHandle_seasonality, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_hasSeasonality", _wrap_ZeroInflationTermStructureHandle_hasSeasonality, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_dayCounter", _wrap_ZeroInflationTermStructureHandle_dayCounter, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_timeFromReference", _wrap_ZeroInflationTermStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "ZeroInflationTermStructureHandle_calendar", _wrap_ZeroInflationTermStructureHandle_calendar, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_referenceDate", _wrap_ZeroInflationTermStructureHandle_referenceDate, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_maxDate", _wrap_ZeroInflationTermStructureHandle_maxDate, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_maxTime", _wrap_ZeroInflationTermStructureHandle_maxTime, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_enableExtrapolation", _wrap_ZeroInflationTermStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_disableExtrapolation", _wrap_ZeroInflationTermStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_allowsExtrapolation", _wrap_ZeroInflationTermStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_swigregister", ZeroInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_swiginit", ZeroInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableZeroInflationTermStructureHandle", _wrap_new_RelinkableZeroInflationTermStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableZeroInflationTermStructureHandle_linkTo", _wrap_RelinkableZeroInflationTermStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableZeroInflationTermStructureHandle_reset", _wrap_RelinkableZeroInflationTermStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableZeroInflationTermStructureHandle", _wrap_delete_RelinkableZeroInflationTermStructureHandle, METH_O, NULL},
	 { "RelinkableZeroInflationTermStructureHandle_swigregister", RelinkableZeroInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableZeroInflationTermStructureHandle_swiginit", RelinkableZeroInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "Region_name", _wrap_Region_name, METH_O, NULL},
	 { "Region_code", _wrap_Region_code, METH_O, NULL},
	 { "delete_Region", _wrap_delete_Region, METH_O, NULL},
	 { "Region_swigregister", Region_swigregister, METH_O, NULL},
	 { "new_CustomRegion", _wrap_new_CustomRegion, METH_VARARGS, NULL},
	 { "delete_CustomRegion", _wrap_delete_CustomRegion, METH_O, NULL},
	 { "CustomRegion_swigregister", CustomRegion_swigregister, METH_O, NULL},
	 { "CustomRegion_swiginit", CustomRegion_swiginit, METH_VARARGS, NULL},
	 { "InflationIndex_familyName", _wrap_InflationIndex_familyName, METH_O, NULL},
	 { "InflationIndex_region", _wrap_InflationIndex_region, METH_O, NULL},
	 { "InflationIndex_revised", _wrap_InflationIndex_revised, METH_O, NULL},
	 { "InflationIndex_interpolated", _wrap_InflationIndex_interpolated, METH_O, NULL},
	 { "InflationIndex_frequency", _wrap_InflationIndex_frequency, METH_O, NULL},
	 { "InflationIndex_availabilityLag", _wrap_InflationIndex_availabilityLag, METH_O, NULL},
	 { "InflationIndex_currency", _wrap_InflationIndex_currency, METH_O, NULL},
	 { "delete_InflationIndex", _wrap_delete_InflationIndex, METH_O, NULL},
	 { "InflationIndex_swigregister", InflationIndex_swigregister, METH_O, NULL},
	 { "new_ZeroInflationIndex", _wrap_new_ZeroInflationIndex, METH_VARARGS, NULL},
	 { "ZeroInflationIndex_zeroInflationTermStructure", _wrap_ZeroInflationIndex_zeroInflationTermStructure, METH_O, NULL},
	 { "ZeroInflationIndex_clone", _wrap_ZeroInflationIndex_clone, METH_VARARGS, NULL},
	 { "delete_ZeroInflationIndex", _wrap_delete_ZeroInflationIndex, METH_O, NULL},
	 { "ZeroInflationIndex_swigregister", ZeroInflationIndex_swigregister, METH_O, NULL},
	 { "ZeroInflationIndex_swiginit", ZeroInflationIndex_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationIndex", _wrap_new_YoYInflationIndex, METH_VARARGS, NULL},
	 { "YoYInflationIndex_ratio", _wrap_YoYInflationIndex_ratio, METH_O, NULL},
	 { "YoYInflationIndex_yoyInflationTermStructure", _wrap_YoYInflationIndex_yoyInflationTermStructure, METH_O, NULL},
	 { "YoYInflationIndex_clone", _wrap_YoYInflationIndex_clone, METH_VARARGS, NULL},
	 { "delete_YoYInflationIndex", _wrap_delete_YoYInflationIndex, METH_O, NULL},
	 { "YoYInflationIndex_swigregister", YoYInflationIndex_swigregister, METH_O, NULL},
	 { "YoYInflationIndex_swiginit", YoYInflationIndex_swiginit, METH_VARARGS, NULL},
	 { "new_EUHICP", _wrap_new_EUHICP, METH_VARARGS, NULL},
	 { "delete_EUHICP", _wrap_delete_EUHICP, METH_O, NULL},
	 { "EUHICP_swigregister", EUHICP_swigregister, METH_O, NULL},
	 { "EUHICP_swiginit", EUHICP_swiginit, METH_VARARGS, NULL},
	 { "new_EUHICPXT", _wrap_new_EUHICPXT, METH_VARARGS, NULL},
	 { "delete_EUHICPXT", _wrap_delete_EUHICPXT, METH_O, NULL},
	 { "EUHICPXT_swigregister", EUHICPXT_swigregister, METH_O, NULL},
	 { "EUHICPXT_swiginit", EUHICPXT_swiginit, METH_VARARGS, NULL},
	 { "new_FRHICP", _wrap_new_FRHICP, METH_VARARGS, NULL},
	 { "delete_FRHICP", _wrap_delete_FRHICP, METH_O, NULL},
	 { "FRHICP_swigregister", FRHICP_swigregister, METH_O, NULL},
	 { "FRHICP_swiginit", FRHICP_swiginit, METH_VARARGS, NULL},
	 { "new_UKRPI", _wrap_new_UKRPI, METH_VARARGS, NULL},
	 { "delete_UKRPI", _wrap_delete_UKRPI, METH_O, NULL},
	 { "UKRPI_swigregister", UKRPI_swigregister, METH_O, NULL},
	 { "UKRPI_swiginit", UKRPI_swiginit, METH_VARARGS, NULL},
	 { "new_USCPI", _wrap_new_USCPI, METH_VARARGS, NULL},
	 { "delete_USCPI", _wrap_delete_USCPI, METH_O, NULL},
	 { "USCPI_swigregister", USCPI_swigregister, METH_O, NULL},
	 { "USCPI_swiginit", USCPI_swiginit, METH_VARARGS, NULL},
	 { "new_ZACPI", _wrap_new_ZACPI, METH_VARARGS, NULL},
	 { "delete_ZACPI", _wrap_delete_ZACPI, METH_O, NULL},
	 { "ZACPI_swigregister", ZACPI_swigregister, METH_O, NULL},
	 { "ZACPI_swiginit", ZACPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYEUHICP", _wrap_new_YYEUHICP, METH_VARARGS, NULL},
	 { "delete_YYEUHICP", _wrap_delete_YYEUHICP, METH_O, NULL},
	 { "YYEUHICP_swigregister", YYEUHICP_swigregister, METH_O, NULL},
	 { "YYEUHICP_swiginit", YYEUHICP_swiginit, METH_VARARGS, NULL},
	 { "new_YYEUHICPXT", _wrap_new_YYEUHICPXT, METH_VARARGS, NULL},
	 { "delete_YYEUHICPXT", _wrap_delete_YYEUHICPXT, METH_O, NULL},
	 { "YYEUHICPXT_swigregister", YYEUHICPXT_swigregister, METH_O, NULL},
	 { "YYEUHICPXT_swiginit", YYEUHICPXT_swiginit, METH_VARARGS, NULL},
	 { "new_YYEUHICPr", _wrap_new_YYEUHICPr, METH_VARARGS, NULL},
	 { "delete_YYEUHICPr", _wrap_delete_YYEUHICPr, METH_O, NULL},
	 { "YYEUHICPr_swigregister", YYEUHICPr_swigregister, METH_O, NULL},
	 { "YYEUHICPr_swiginit", YYEUHICPr_swiginit, METH_VARARGS, NULL},
	 { "new_YYFRHICP", _wrap_new_YYFRHICP, METH_VARARGS, NULL},
	 { "delete_YYFRHICP", _wrap_delete_YYFRHICP, METH_O, NULL},
	 { "YYFRHICP_swigregister", YYFRHICP_swigregister, METH_O, NULL},
	 { "YYFRHICP_swiginit", YYFRHICP_swiginit, METH_VARARGS, NULL},
	 { "new_YYFRHICPr", _wrap_new_YYFRHICPr, METH_VARARGS, NULL},
	 { "delete_YYFRHICPr", _wrap_delete_YYFRHICPr, METH_O, NULL},
	 { "YYFRHICPr_swigregister", YYFRHICPr_swigregister, METH_O, NULL},
	 { "YYFRHICPr_swiginit", YYFRHICPr_swiginit, METH_VARARGS, NULL},
	 { "new_YYUKRPI", _wrap_new_YYUKRPI, METH_VARARGS, NULL},
	 { "delete_YYUKRPI", _wrap_delete_YYUKRPI, METH_O, NULL},
	 { "YYUKRPI_swigregister", YYUKRPI_swigregister, METH_O, NULL},
	 { "YYUKRPI_swiginit", YYUKRPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYUKRPIr", _wrap_new_YYUKRPIr, METH_VARARGS, NULL},
	 { "delete_YYUKRPIr", _wrap_delete_YYUKRPIr, METH_O, NULL},
	 { "YYUKRPIr_swigregister", YYUKRPIr_swigregister, METH_O, NULL},
	 { "YYUKRPIr_swiginit", YYUKRPIr_swiginit, METH_VARARGS, NULL},
	 { "new_YYUSCPI", _wrap_new_YYUSCPI, METH_VARARGS, NULL},
	 { "delete_YYUSCPI", _wrap_delete_YYUSCPI, METH_O, NULL},
	 { "YYUSCPI_swigregister", YYUSCPI_swigregister, METH_O, NULL},
	 { "YYUSCPI_swiginit", YYUSCPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYUSCPIr", _wrap_new_YYUSCPIr, METH_VARARGS, NULL},
	 { "delete_YYUSCPIr", _wrap_delete_YYUSCPIr, METH_O, NULL},
	 { "YYUSCPIr_swigregister", YYUSCPIr_swigregister, METH_O, NULL},
	 { "YYUSCPIr_swiginit", YYUSCPIr_swiginit, METH_VARARGS, NULL},
	 { "new_YYZACPI", _wrap_new_YYZACPI, METH_VARARGS, NULL},
	 { "delete_YYZACPI", _wrap_delete_YYZACPI, METH_O, NULL},
	 { "YYZACPI_swigregister", YYZACPI_swigregister, METH_O, NULL},
	 { "YYZACPI_swiginit", YYZACPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYZACPIr", _wrap_new_YYZACPIr, METH_VARARGS, NULL},
	 { "delete_YYZACPIr", _wrap_delete_YYZACPIr, METH_O, NULL},
	 { "YYZACPIr_swigregister", YYZACPIr_swigregister, METH_O, NULL},
	 { "YYZACPIr_swiginit", YYZACPIr_swiginit, METH_VARARGS, NULL},
	 { "new_AUCPI", _wrap_new_AUCPI, METH_VARARGS, NULL},
	 { "delete_AUCPI", _wrap_delete_AUCPI, METH_O, NULL},
	 { "AUCPI_swigregister", AUCPI_swigregister, METH_O, NULL},
	 { "AUCPI_swiginit", AUCPI_swiginit, METH_VARARGS, NULL},
	 { "new_CPI", _wrap_new_CPI, METH_NOARGS, NULL},
	 { "delete_CPI", _wrap_delete_CPI, METH_O, NULL},
	 { "CPI_swigregister", CPI_swigregister, METH_O, NULL},
	 { "CPI_swiginit", CPI_swiginit, METH_VARARGS, NULL},
	 { "InflationCoupon_fixingDate", _wrap_InflationCoupon_fixingDate, METH_O, NULL},
	 { "InflationCoupon_fixingDays", _wrap_InflationCoupon_fixingDays, METH_O, NULL},
	 { "InflationCoupon_observationLag", _wrap_InflationCoupon_observationLag, METH_O, NULL},
	 { "InflationCoupon_indexFixing", _wrap_InflationCoupon_indexFixing, METH_O, NULL},
	 { "InflationCoupon_index", _wrap_InflationCoupon_index, METH_O, NULL},
	 { "delete_InflationCoupon", _wrap_delete_InflationCoupon, METH_O, NULL},
	 { "InflationCoupon_swigregister", InflationCoupon_swigregister, METH_O, NULL},
	 { "as_inflation_coupon", _wrap_as_inflation_coupon, METH_O, NULL},
	 { "CPICoupon_fixedRate", _wrap_CPICoupon_fixedRate, METH_O, NULL},
	 { "CPICoupon_spread", _wrap_CPICoupon_spread, METH_O, NULL},
	 { "CPICoupon_adjustedFixing", _wrap_CPICoupon_adjustedFixing, METH_O, NULL},
	 { "CPICoupon_baseCPI", _wrap_CPICoupon_baseCPI, METH_O, NULL},
	 { "CPICoupon_observationInterpolation", _wrap_CPICoupon_observationInterpolation, METH_O, NULL},
	 { "CPICoupon_cpiIndex", _wrap_CPICoupon_cpiIndex, METH_O, NULL},
	 { "delete_CPICoupon", _wrap_delete_CPICoupon, METH_O, NULL},
	 { "CPICoupon_swigregister", CPICoupon_swigregister, METH_O, NULL},
	 { "as_cpi_coupon", _wrap_as_cpi_coupon, METH_O, NULL},
	 { "ZeroHelper_quote", _wrap_ZeroHelper_quote, METH_O, NULL},
	 { "ZeroHelper_latestDate", _wrap_ZeroHelper_latestDate, METH_O, NULL},
	 { "ZeroHelper_earliestDate", _wrap_ZeroHelper_earliestDate, METH_O, NULL},
	 { "ZeroHelper_maturityDate", _wrap_ZeroHelper_maturityDate, METH_O, NULL},
	 { "ZeroHelper_latestRelevantDate", _wrap_ZeroHelper_latestRelevantDate, METH_O, NULL},
	 { "ZeroHelper_pillarDate", _wrap_ZeroHelper_pillarDate, METH_O, NULL},
	 { "ZeroHelper_impliedQuote", _wrap_ZeroHelper_impliedQuote, METH_O, NULL},
	 { "ZeroHelper_quoteError", _wrap_ZeroHelper_quoteError, METH_O, NULL},
	 { "delete_ZeroHelper", _wrap_delete_ZeroHelper, METH_O, NULL},
	 { "ZeroHelper_swigregister", ZeroHelper_swigregister, METH_O, NULL},
	 { "YoYHelper_quote", _wrap_YoYHelper_quote, METH_O, NULL},
	 { "YoYHelper_latestDate", _wrap_YoYHelper_latestDate, METH_O, NULL},
	 { "YoYHelper_earliestDate", _wrap_YoYHelper_earliestDate, METH_O, NULL},
	 { "YoYHelper_maturityDate", _wrap_YoYHelper_maturityDate, METH_O, NULL},
	 { "YoYHelper_latestRelevantDate", _wrap_YoYHelper_latestRelevantDate, METH_O, NULL},
	 { "YoYHelper_pillarDate", _wrap_YoYHelper_pillarDate, METH_O, NULL},
	 { "YoYHelper_impliedQuote", _wrap_YoYHelper_impliedQuote, METH_O, NULL},
	 { "YoYHelper_quoteError", _wrap_YoYHelper_quoteError, METH_O, NULL},
	 { "delete_YoYHelper", _wrap_delete_YoYHelper, METH_O, NULL},
	 { "YoYHelper_swigregister", YoYHelper_swigregister, METH_O, NULL},
	 { "YoYOptionHelper_quote", _wrap_YoYOptionHelper_quote, METH_O, NULL},
	 { "YoYOptionHelper_latestDate", _wrap_YoYOptionHelper_latestDate, METH_O, NULL},
	 { "YoYOptionHelper_earliestDate", _wrap_YoYOptionHelper_earliestDate, METH_O, NULL},
	 { "YoYOptionHelper_maturityDate", _wrap_YoYOptionHelper_maturityDate, METH_O, NULL},
	 { "YoYOptionHelper_latestRelevantDate", _wrap_YoYOptionHelper_latestRelevantDate, METH_O, NULL},
	 { "YoYOptionHelper_pillarDate", _wrap_YoYOptionHelper_pillarDate, METH_O, NULL},
	 { "YoYOptionHelper_impliedQuote", _wrap_YoYOptionHelper_impliedQuote, METH_O, NULL},
	 { "YoYOptionHelper_quoteError", _wrap_YoYOptionHelper_quoteError, METH_O, NULL},
	 { "delete_YoYOptionHelper", _wrap_delete_YoYOptionHelper, METH_O, NULL},
	 { "YoYOptionHelper_swigregister", YoYOptionHelper_swigregister, METH_O, NULL},
	 { "ZeroHelperVector_iterator", _wrap_ZeroHelperVector_iterator, METH_O, NULL},
	 { "ZeroHelperVector___nonzero__", _wrap_ZeroHelperVector___nonzero__, METH_O, NULL},
	 { "ZeroHelperVector___bool__", _wrap_ZeroHelperVector___bool__, METH_O, NULL},
	 { "ZeroHelperVector___len__", _wrap_ZeroHelperVector___len__, METH_O, NULL},
	 { "ZeroHelperVector___getslice__", _wrap_ZeroHelperVector___getslice__, METH_VARARGS, NULL},
	 { "ZeroHelperVector___setslice__", _wrap_ZeroHelperVector___setslice__, METH_VARARGS, NULL},
	 { "ZeroHelperVector___delslice__", _wrap_ZeroHelperVector___delslice__, METH_VARARGS, NULL},
	 { "ZeroHelperVector___delitem__", _wrap_ZeroHelperVector___delitem__, METH_VARARGS, NULL},
	 { "ZeroHelperVector___getitem__", _wrap_ZeroHelperVector___getitem__, METH_VARARGS, NULL},
	 { "ZeroHelperVector___setitem__", _wrap_ZeroHelperVector___setitem__, METH_VARARGS, NULL},
	 { "ZeroHelperVector_pop", _wrap_ZeroHelperVector_pop, METH_O, NULL},
	 { "ZeroHelperVector_append", _wrap_ZeroHelperVector_append, METH_VARARGS, NULL},
	 { "ZeroHelperVector_empty", _wrap_ZeroHelperVector_empty, METH_O, NULL},
	 { "ZeroHelperVector_size", _wrap_ZeroHelperVector_size, METH_O, NULL},
	 { "ZeroHelperVector_swap", _wrap_ZeroHelperVector_swap, METH_VARARGS, NULL},
	 { "ZeroHelperVector_begin", _wrap_ZeroHelperVector_begin, METH_O, NULL},
	 { "ZeroHelperVector_end", _wrap_ZeroHelperVector_end, METH_O, NULL},
	 { "ZeroHelperVector_rbegin", _wrap_ZeroHelperVector_rbegin, METH_O, NULL},
	 { "ZeroHelperVector_rend", _wrap_ZeroHelperVector_rend, METH_O, NULL},
	 { "ZeroHelperVector_clear", _wrap_ZeroHelperVector_clear, METH_O, NULL},
	 { "ZeroHelperVector_get_allocator", _wrap_ZeroHelperVector_get_allocator, METH_O, NULL},
	 { "ZeroHelperVector_pop_back", _wrap_ZeroHelperVector_pop_back, METH_O, NULL},
	 { "ZeroHelperVector_erase", _wrap_ZeroHelperVector_erase, METH_VARARGS, NULL},
	 { "new_ZeroHelperVector", _wrap_new_ZeroHelperVector, METH_VARARGS, NULL},
	 { "ZeroHelperVector_push_back", _wrap_ZeroHelperVector_push_back, METH_VARARGS, NULL},
	 { "ZeroHelperVector_front", _wrap_ZeroHelperVector_front, METH_O, NULL},
	 { "ZeroHelperVector_back", _wrap_ZeroHelperVector_back, METH_O, NULL},
	 { "ZeroHelperVector_assign", _wrap_ZeroHelperVector_assign, METH_VARARGS, NULL},
	 { "ZeroHelperVector_resize", _wrap_ZeroHelperVector_resize, METH_VARARGS, NULL},
	 { "ZeroHelperVector_insert", _wrap_ZeroHelperVector_insert, METH_VARARGS, NULL},
	 { "ZeroHelperVector_reserve", _wrap_ZeroHelperVector_reserve, METH_VARARGS, NULL},
	 { "ZeroHelperVector_capacity", _wrap_ZeroHelperVector_capacity, METH_O, NULL},
	 { "delete_ZeroHelperVector", _wrap_delete_ZeroHelperVector, METH_O, NULL},
	 { "ZeroHelperVector_swigregister", ZeroHelperVector_swigregister, METH_O, NULL},
	 { "ZeroHelperVector_swiginit", ZeroHelperVector_swiginit, METH_VARARGS, NULL},
	 { "YoYHelperVector_iterator", _wrap_YoYHelperVector_iterator, METH_O, NULL},
	 { "YoYHelperVector___nonzero__", _wrap_YoYHelperVector___nonzero__, METH_O, NULL},
	 { "YoYHelperVector___bool__", _wrap_YoYHelperVector___bool__, METH_O, NULL},
	 { "YoYHelperVector___len__", _wrap_YoYHelperVector___len__, METH_O, NULL},
	 { "YoYHelperVector___getslice__", _wrap_YoYHelperVector___getslice__, METH_VARARGS, NULL},
	 { "YoYHelperVector___setslice__", _wrap_YoYHelperVector___setslice__, METH_VARARGS, NULL},
	 { "YoYHelperVector___delslice__", _wrap_YoYHelperVector___delslice__, METH_VARARGS, NULL},
	 { "YoYHelperVector___delitem__", _wrap_YoYHelperVector___delitem__, METH_VARARGS, NULL},
	 { "YoYHelperVector___getitem__", _wrap_YoYHelperVector___getitem__, METH_VARARGS, NULL},
	 { "YoYHelperVector___setitem__", _wrap_YoYHelperVector___setitem__, METH_VARARGS, NULL},
	 { "YoYHelperVector_pop", _wrap_YoYHelperVector_pop, METH_O, NULL},
	 { "YoYHelperVector_append", _wrap_YoYHelperVector_append, METH_VARARGS, NULL},
	 { "YoYHelperVector_empty", _wrap_YoYHelperVector_empty, METH_O, NULL},
	 { "YoYHelperVector_size", _wrap_YoYHelperVector_size, METH_O, NULL},
	 { "YoYHelperVector_swap", _wrap_YoYHelperVector_swap, METH_VARARGS, NULL},
	 { "YoYHelperVector_begin", _wrap_YoYHelperVector_begin, METH_O, NULL},
	 { "YoYHelperVector_end", _wrap_YoYHelperVector_end, METH_O, NULL},
	 { "YoYHelperVector_rbegin", _wrap_YoYHelperVector_rbegin, METH_O, NULL},
	 { "YoYHelperVector_rend", _wrap_YoYHelperVector_rend, METH_O, NULL},
	 { "YoYHelperVector_clear", _wrap_YoYHelperVector_clear, METH_O, NULL},
	 { "YoYHelperVector_get_allocator", _wrap_YoYHelperVector_get_allocator, METH_O, NULL},
	 { "YoYHelperVector_pop_back", _wrap_YoYHelperVector_pop_back, METH_O, NULL},
	 { "YoYHelperVector_erase", _wrap_YoYHelperVector_erase, METH_VARARGS, NULL},
	 { "new_YoYHelperVector", _wrap_new_YoYHelperVector, METH_VARARGS, NULL},
	 { "YoYHelperVector_push_back", _wrap_YoYHelperVector_push_back, METH_VARARGS, NULL},
	 { "YoYHelperVector_front", _wrap_YoYHelperVector_front, METH_O, NULL},
	 { "YoYHelperVector_back", _wrap_YoYHelperVector_back, METH_O, NULL},
	 { "YoYHelperVector_assign", _wrap_YoYHelperVector_assign, METH_VARARGS, NULL},
	 { "YoYHelperVector_resize", _wrap_YoYHelperVector_resize, METH_VARARGS, NULL},
	 { "YoYHelperVector_insert", _wrap_YoYHelperVector_insert, METH_VARARGS, NULL},
	 { "YoYHelperVector_reserve", _wrap_YoYHelperVector_reserve, METH_VARARGS, NULL},
	 { "YoYHelperVector_capacity", _wrap_YoYHelperVector_capacity, METH_O, NULL},
	 { "delete_YoYHelperVector", _wrap_delete_YoYHelperVector, METH_O, NULL},
	 { "YoYHelperVector_swigregister", YoYHelperVector_swigregister, METH_O, NULL},
	 { "YoYHelperVector_swiginit", YoYHelperVector_swiginit, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_iterator", _wrap_YoYOptionHelperVector_iterator, METH_O, NULL},
	 { "YoYOptionHelperVector___nonzero__", _wrap_YoYOptionHelperVector___nonzero__, METH_O, NULL},
	 { "YoYOptionHelperVector___bool__", _wrap_YoYOptionHelperVector___bool__, METH_O, NULL},
	 { "YoYOptionHelperVector___len__", _wrap_YoYOptionHelperVector___len__, METH_O, NULL},
	 { "YoYOptionHelperVector___getslice__", _wrap_YoYOptionHelperVector___getslice__, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector___setslice__", _wrap_YoYOptionHelperVector___setslice__, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector___delslice__", _wrap_YoYOptionHelperVector___delslice__, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector___delitem__", _wrap_YoYOptionHelperVector___delitem__, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector___getitem__", _wrap_YoYOptionHelperVector___getitem__, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector___setitem__", _wrap_YoYOptionHelperVector___setitem__, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_pop", _wrap_YoYOptionHelperVector_pop, METH_O, NULL},
	 { "YoYOptionHelperVector_append", _wrap_YoYOptionHelperVector_append, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_empty", _wrap_YoYOptionHelperVector_empty, METH_O, NULL},
	 { "YoYOptionHelperVector_size", _wrap_YoYOptionHelperVector_size, METH_O, NULL},
	 { "YoYOptionHelperVector_swap", _wrap_YoYOptionHelperVector_swap, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_begin", _wrap_YoYOptionHelperVector_begin, METH_O, NULL},
	 { "YoYOptionHelperVector_end", _wrap_YoYOptionHelperVector_end, METH_O, NULL},
	 { "YoYOptionHelperVector_rbegin", _wrap_YoYOptionHelperVector_rbegin, METH_O, NULL},
	 { "YoYOptionHelperVector_rend", _wrap_YoYOptionHelperVector_rend, METH_O, NULL},
	 { "YoYOptionHelperVector_clear", _wrap_YoYOptionHelperVector_clear, METH_O, NULL},
	 { "YoYOptionHelperVector_get_allocator", _wrap_YoYOptionHelperVector_get_allocator, METH_O, NULL},
	 { "YoYOptionHelperVector_pop_back", _wrap_YoYOptionHelperVector_pop_back, METH_O, NULL},
	 { "YoYOptionHelperVector_erase", _wrap_YoYOptionHelperVector_erase, METH_VARARGS, NULL},
	 { "new_YoYOptionHelperVector", _wrap_new_YoYOptionHelperVector, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_push_back", _wrap_YoYOptionHelperVector_push_back, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_front", _wrap_YoYOptionHelperVector_front, METH_O, NULL},
	 { "YoYOptionHelperVector_back", _wrap_YoYOptionHelperVector_back, METH_O, NULL},
	 { "YoYOptionHelperVector_assign", _wrap_YoYOptionHelperVector_assign, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_resize", _wrap_YoYOptionHelperVector_resize, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_insert", _wrap_YoYOptionHelperVector_insert, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_reserve", _wrap_YoYOptionHelperVector_reserve, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_capacity", _wrap_YoYOptionHelperVector_capacity, METH_O, NULL},
	 { "delete_YoYOptionHelperVector", _wrap_delete_YoYOptionHelperVector, METH_O, NULL},
	 { "YoYOptionHelperVector_swigregister", YoYOptionHelperVector_swigregister, METH_O, NULL},
	 { "YoYOptionHelperVector_swiginit", YoYOptionHelperVector_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroCouponInflationSwapHelper", _wrap_new_ZeroCouponInflationSwapHelper, METH_VARARGS, NULL},
	 { "delete_ZeroCouponInflationSwapHelper", _wrap_delete_ZeroCouponInflationSwapHelper, METH_O, NULL},
	 { "ZeroCouponInflationSwapHelper_swigregister", ZeroCouponInflationSwapHelper_swigregister, METH_O, NULL},
	 { "ZeroCouponInflationSwapHelper_swiginit", ZeroCouponInflationSwapHelper_swiginit, METH_VARARGS, NULL},
	 { "new_YearOnYearInflationSwapHelper", _wrap_new_YearOnYearInflationSwapHelper, METH_VARARGS, NULL},
	 { "delete_YearOnYearInflationSwapHelper", _wrap_delete_YearOnYearInflationSwapHelper, METH_O, NULL},
	 { "YearOnYearInflationSwapHelper_swigregister", YearOnYearInflationSwapHelper_swigregister, METH_O, NULL},
	 { "YearOnYearInflationSwapHelper_swiginit", YearOnYearInflationSwapHelper_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseZeroInflation", (PyCFunction)(void(*)(void))_wrap_new_PiecewiseZeroInflation, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PiecewiseZeroInflation_dates", _wrap_PiecewiseZeroInflation_dates, METH_O, NULL},
	 { "PiecewiseZeroInflation_times", _wrap_PiecewiseZeroInflation_times, METH_O, NULL},
	 { "PiecewiseZeroInflation_nodes", _wrap_PiecewiseZeroInflation_nodes, METH_O, NULL},
	 { "delete_PiecewiseZeroInflation", _wrap_delete_PiecewiseZeroInflation, METH_O, NULL},
	 { "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, NULL},
	 { "PiecewiseYoYInflation_dates", _wrap_PiecewiseYoYInflation_dates, METH_O, NULL},
	 { "PiecewiseYoYInflation_times", _wrap_PiecewiseYoYInflation_times, METH_O, NULL},
	 { "PiecewiseYoYInflation_nodes", _wrap_PiecewiseYoYInflation_nodes, METH_O, NULL},
	 { "delete_PiecewiseYoYInflation", _wrap_delete_PiecewiseYoYInflation, METH_O, NULL},
	 { "PiecewiseYoYInflation_swigregister", PiecewiseYoYInflation_swigregister, METH_O, NULL},
	 { "PiecewiseYoYInflation_swiginit", PiecewiseYoYInflation_swiginit, METH_VARARGS, NULL},
	 { "inflationBaseDate", _wrap_inflationBaseDate, METH_VARARGS, NULL},
	 { "yoyInflationLeg", (PyCFunction)(void(*)(void))_wrap_yoyInflationLeg, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_ZeroCouponInflationSwap", _wrap_new_ZeroCouponInflationSwap, METH_VARARGS, NULL},
	 { "ZeroCouponInflationSwap_fairRate", _wrap_ZeroCouponInflationSwap_fairRate, METH_O, NULL},
	 { "ZeroCouponInflationSwap_fixedLegNPV", _wrap_ZeroCouponInflationSwap_fixedLegNPV, METH_O, NULL},
	 { "ZeroCouponInflationSwap_inflationLegNPV", _wrap_ZeroCouponInflationSwap_inflationLegNPV, METH_O, NULL},
	 { "ZeroCouponInflationSwap_fixedLeg", _wrap_ZeroCouponInflationSwap_fixedLeg, METH_O, NULL},
	 { "ZeroCouponInflationSwap_inflationLeg", _wrap_ZeroCouponInflationSwap_inflationLeg, METH_O, NULL},
	 { "ZeroCouponInflationSwap_type", _wrap_ZeroCouponInflationSwap_type, METH_O, NULL},
	 { "delete_ZeroCouponInflationSwap", _wrap_delete_ZeroCouponInflationSwap, METH_O, NULL},
	 { "ZeroCouponInflationSwap_swigregister", ZeroCouponInflationSwap_swigregister, METH_O, NULL},
	 { "ZeroCouponInflationSwap_swiginit", ZeroCouponInflationSwap_swiginit, METH_VARARGS, NULL},
	 { "new_YearOnYearInflationSwap", _wrap_new_YearOnYearInflationSwap, METH_VARARGS, NULL},
	 { "YearOnYearInflationSwap_fairRate", _wrap_YearOnYearInflationSwap_fairRate, METH_O, NULL},
	 { "YearOnYearInflationSwap_fixedLegNPV", _wrap_YearOnYearInflationSwap_fixedLegNPV, METH_O, NULL},
	 { "YearOnYearInflationSwap_yoyLegNPV", _wrap_YearOnYearInflationSwap_yoyLegNPV, METH_O, NULL},
	 { "YearOnYearInflationSwap_fairSpread", _wrap_YearOnYearInflationSwap_fairSpread, METH_O, NULL},
	 { "YearOnYearInflationSwap_fixedLeg", _wrap_YearOnYearInflationSwap_fixedLeg, METH_O, NULL},
	 { "YearOnYearInflationSwap_yoyLeg", _wrap_YearOnYearInflationSwap_yoyLeg, METH_O, NULL},
	 { "delete_YearOnYearInflationSwap", _wrap_delete_YearOnYearInflationSwap, METH_O, NULL},
	 { "YearOnYearInflationSwap_swigregister", YearOnYearInflationSwap_swigregister, METH_O, NULL},
	 { "YearOnYearInflationSwap_swiginit", YearOnYearInflationSwap_swiginit, METH_VARARGS, NULL},
	 { "new_CPISwap", _wrap_new_CPISwap, METH_VARARGS, NULL},
	 { "CPISwap_fairRate", _wrap_CPISwap_fairRate, METH_O, NULL},
	 { "CPISwap_floatLegNPV", _wrap_CPISwap_floatLegNPV, METH_O, NULL},
	 { "CPISwap_fairSpread", _wrap_CPISwap_fairSpread, METH_O, NULL},
	 { "CPISwap_fixedLegNPV", _wrap_CPISwap_fixedLegNPV, METH_O, NULL},
	 { "CPISwap_cpiLeg", _wrap_CPISwap_cpiLeg, METH_O, NULL},
	 { "CPISwap_floatLeg", _wrap_CPISwap_floatLeg, METH_O, NULL},
	 { "delete_CPISwap", _wrap_delete_CPISwap, METH_O, NULL},
	 { "CPISwap_swigregister", CPISwap_swigregister, METH_O, NULL},
	 { "CPISwap_swiginit", CPISwap_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCapFloor", _wrap_new_YoYInflationCapFloor, METH_VARARGS, NULL},
	 { "YoYInflationCapFloor_impliedVolatility", _wrap_YoYInflationCapFloor_impliedVolatility, METH_VARARGS, NULL},
	 { "YoYInflationCapFloor_optionletPrices", _wrap_YoYInflationCapFloor_optionletPrices, METH_O, NULL},
	 { "delete_YoYInflationCapFloor", _wrap_delete_YoYInflationCapFloor, METH_O, NULL},
	 { "YoYInflationCapFloor_swigregister", YoYInflationCapFloor_swigregister, METH_O, NULL},
	 { "YoYInflationCapFloor_swiginit", YoYInflationCapFloor_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCap", _wrap_new_YoYInflationCap, METH_VARARGS, NULL},
	 { "delete_YoYInflationCap", _wrap_delete_YoYInflationCap, METH_O, NULL},
	 { "YoYInflationCap_swigregister", YoYInflationCap_swigregister, METH_O, NULL},
	 { "YoYInflationCap_swiginit", YoYInflationCap_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationFloor", _wrap_new_YoYInflationFloor, METH_VARARGS, NULL},
	 { "delete_YoYInflationFloor", _wrap_delete_YoYInflationFloor, METH_O, NULL},
	 { "YoYInflationFloor_swigregister", YoYInflationFloor_swigregister, METH_O, NULL},
	 { "YoYInflationFloor_swiginit", YoYInflationFloor_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCollar", _wrap_new_YoYInflationCollar, METH_VARARGS, NULL},
	 { "delete_YoYInflationCollar", _wrap_delete_YoYInflationCollar, METH_O, NULL},
	 { "YoYInflationCollar_swigregister", YoYInflationCollar_swigregister, METH_O, NULL},
	 { "YoYInflationCollar_swiginit", YoYInflationCollar_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroInflationCurve", (PyCFunction)(void(*)(void))_wrap_new_ZeroInflationCurve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ZeroInflationCurve_dates", _wrap_ZeroInflationCurve_dates, METH_O, NULL},
	 { "ZeroInflationCurve_times", _wrap_ZeroInflationCurve_times, METH_O, NULL},
	 { "ZeroInflationCurve_data", _wrap_ZeroInflationCurve_data, METH_O, NULL},
	 { "ZeroInflationCurve_rates", _wrap_ZeroInflationCurve_rates, METH_O, NULL},
	 { "ZeroInflationCurve_nodes", _wrap_ZeroInflationCurve_nodes, METH_O, NULL},
	 { "delete_ZeroInflationCurve", _wrap_delete_ZeroInflationCurve, METH_O, NULL},
	 { "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, NULL},
	 { "YoYInflationCurve_dates", _wrap_YoYInflationCurve_dates, METH_O, NULL},
	 { "YoYInflationCurve_times", _wrap_YoYInflationCurve_times, METH_O, NULL},
	 { "YoYInflationCurve_data", _wrap_YoYInflationCurve_data, METH_O, NULL},
	 { "YoYInflationCurve_rates", _wrap_YoYInflationCurve_rates, METH_O, NULL},
	 { "YoYInflationCurve_nodes", _wrap_YoYInflationCurve_nodes, METH_O, NULL},
	 { "delete_YoYInflationCurve", _wrap_delete_YoYInflationCurve, METH_O, NULL},
	 { "YoYInflationCurve_swigregister", YoYInflationCurve_swigregister, METH_O, NULL},
	 { "YoYInflationCurve_swiginit", YoYInflationCurve_swiginit, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates", _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_atmYoYSwapDateRates", _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapDateRates, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_YoYTS", _wrap_YoYCapFloorTermPriceSurface_YoYTS, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_yoyIndex", _wrap_YoYCapFloorTermPriceSurface_yoyIndex, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_businessDayConvention", _wrap_YoYCapFloorTermPriceSurface_businessDayConvention, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_fixingDays", _wrap_YoYCapFloorTermPriceSurface_fixingDays, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_price", _wrap_YoYCapFloorTermPriceSurface_price, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_capPrice", _wrap_YoYCapFloorTermPriceSurface_capPrice, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_floorPrice", _wrap_YoYCapFloorTermPriceSurface_floorPrice, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_atmYoYSwapRate", _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_atmYoYRate", _wrap_YoYCapFloorTermPriceSurface_atmYoYRate, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_strikes", _wrap_YoYCapFloorTermPriceSurface_strikes, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_capStrikes", _wrap_YoYCapFloorTermPriceSurface_capStrikes, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_floorStrikes", _wrap_YoYCapFloorTermPriceSurface_floorStrikes, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_maturities", _wrap_YoYCapFloorTermPriceSurface_maturities, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_minStrike", _wrap_YoYCapFloorTermPriceSurface_minStrike, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_maxStrike", _wrap_YoYCapFloorTermPriceSurface_maxStrike, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_minMaturity", _wrap_YoYCapFloorTermPriceSurface_minMaturity, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_maxMaturity", _wrap_YoYCapFloorTermPriceSurface_maxMaturity, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor", _wrap_YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor, METH_VARARGS, NULL},
	 { "delete_YoYCapFloorTermPriceSurface", _wrap_delete_YoYCapFloorTermPriceSurface, METH_O, NULL},
	 { "YoYCapFloorTermPriceSurface_swigregister", YoYCapFloorTermPriceSurface_swigregister, METH_O, NULL},
	 { "new_YoYInflationCapFloorTermPriceSurface", _wrap_new_YoYInflationCapFloorTermPriceSurface, METH_VARARGS, NULL},
	 { "delete_YoYInflationCapFloorTermPriceSurface", _wrap_delete_YoYInflationCapFloorTermPriceSurface, METH_O, NULL},
	 { "YoYInflationCapFloorTermPriceSurface_swigregister", YoYInflationCapFloorTermPriceSurface_swigregister, METH_O, NULL},
	 { "YoYInflationCapFloorTermPriceSurface_swiginit", YoYInflationCapFloorTermPriceSurface_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationBlackCapFloorEngine", _wrap_new_YoYInflationBlackCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_YoYInflationBlackCapFloorEngine", _wrap_delete_YoYInflationBlackCapFloorEngine, METH_O, NULL},
	 { "YoYInflationBlackCapFloorEngine_swigregister", YoYInflationBlackCapFloorEngine_swigregister, METH_O, NULL},
	 { "YoYInflationBlackCapFloorEngine_swiginit", YoYInflationBlackCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationUnitDisplacedBlackCapFloorEngine", _wrap_new_YoYInflationUnitDisplacedBlackCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_YoYInflationUnitDisplacedBlackCapFloorEngine", _wrap_delete_YoYInflationUnitDisplacedBlackCapFloorEngine, METH_O, NULL},
	 { "YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister", YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister, METH_O, NULL},
	 { "YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit", YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationBachelierCapFloorEngine", _wrap_new_YoYInflationBachelierCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_YoYInflationBachelierCapFloorEngine", _wrap_delete_YoYInflationBachelierCapFloorEngine, METH_O, NULL},
	 { "YoYInflationBachelierCapFloorEngine_swigregister", YoYInflationBachelierCapFloorEngine_swigregister, METH_O, NULL},
	 { "YoYInflationBachelierCapFloorEngine_swiginit", YoYInflationBachelierCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_YoYOptionletHelper", _wrap_new_YoYOptionletHelper, METH_VARARGS, NULL},
	 { "delete_YoYOptionletHelper", _wrap_delete_YoYOptionletHelper, METH_O, NULL},
	 { "YoYOptionletHelper_swigregister", YoYOptionletHelper_swigregister, METH_O, NULL},
	 { "YoYOptionletHelper_swiginit", YoYOptionletHelper_swiginit, METH_VARARGS, NULL},
	 { "YoYOptionletStripper_initialize", _wrap_YoYOptionletStripper_initialize, METH_VARARGS, NULL},
	 { "YoYOptionletStripper_maxStrike", _wrap_YoYOptionletStripper_maxStrike, METH_O, NULL},
	 { "YoYOptionletStripper_strikes", _wrap_YoYOptionletStripper_strikes, METH_O, NULL},
	 { "YoYOptionletStripper_slice", _wrap_YoYOptionletStripper_slice, METH_VARARGS, NULL},
	 { "delete_YoYOptionletStripper", _wrap_delete_YoYOptionletStripper, METH_O, NULL},
	 { "YoYOptionletStripper_swigregister", YoYOptionletStripper_swigregister, METH_O, NULL},
	 { "new_InterpolatedYoYInflationOptionletStripper", _wrap_new_InterpolatedYoYInflationOptionletStripper, METH_NOARGS, NULL},
	 { "delete_InterpolatedYoYInflationOptionletStripper", _wrap_delete_InterpolatedYoYInflationOptionletStripper, METH_O, NULL},
	 { "InterpolatedYoYInflationOptionletStripper_swigregister", InterpolatedYoYInflationOptionletStripper_swigregister, METH_O, NULL},
	 { "InterpolatedYoYInflationOptionletStripper_swiginit", InterpolatedYoYInflationOptionletStripper_swiginit, METH_VARARGS, NULL},
	 { "new_InterpolatedYoYInflationOptionletVolatilityCurve", _wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve, METH_VARARGS, NULL},
	 { "delete_InterpolatedYoYInflationOptionletVolatilityCurve", _wrap_delete_InterpolatedYoYInflationOptionletVolatilityCurve, METH_O, NULL},
	 { "InterpolatedYoYInflationOptionletVolatilityCurve_swigregister", InterpolatedYoYInflationOptionletVolatilityCurve_swigregister, METH_O, NULL},
	 { "InterpolatedYoYInflationOptionletVolatilityCurve_swiginit", InterpolatedYoYInflationOptionletVolatilityCurve_swiginit, METH_VARARGS, NULL},
	 { "new_KInterpolatedYoYInflationOptionletVolatilitySurface", _wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface, METH_VARARGS, NULL},
	 { "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice", _wrap_KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice, METH_VARARGS, NULL},
	 { "delete_KInterpolatedYoYInflationOptionletVolatilitySurface", _wrap_delete_KInterpolatedYoYInflationOptionletVolatilitySurface, METH_O, NULL},
	 { "KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister", KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister, METH_O, NULL},
	 { "KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit", KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit, METH_VARARGS, NULL},
	 { "delete_ShortRateModel", _wrap_delete_ShortRateModel, METH_O, NULL},
	 { "ShortRateModel_swigregister", ShortRateModel_swigregister, METH_O, NULL},
	 { "new_ShortRateModelHandle", _wrap_new_ShortRateModelHandle, METH_VARARGS, NULL},
	 { "ShortRateModelHandle___deref__", _wrap_ShortRateModelHandle___deref__, METH_O, NULL},
	 { "ShortRateModelHandle_currentLink", _wrap_ShortRateModelHandle_currentLink, METH_O, NULL},
	 { "ShortRateModelHandle___nonzero__", _wrap_ShortRateModelHandle___nonzero__, METH_O, NULL},
	 { "ShortRateModelHandle___bool__", _wrap_ShortRateModelHandle___bool__, METH_O, NULL},
	 { "ShortRateModelHandle_asObservable", _wrap_ShortRateModelHandle_asObservable, METH_O, NULL},
	 { "delete_ShortRateModelHandle", _wrap_delete_ShortRateModelHandle, METH_O, NULL},
	 { "ShortRateModelHandle_params", _wrap_ShortRateModelHandle_params, METH_O, NULL},
	 { "ShortRateModelHandle_calibrate", _wrap_ShortRateModelHandle_calibrate, METH_VARARGS, NULL},
	 { "ShortRateModelHandle_setParams", _wrap_ShortRateModelHandle_setParams, METH_VARARGS, NULL},
	 { "ShortRateModelHandle_value", _wrap_ShortRateModelHandle_value, METH_VARARGS, NULL},
	 { "ShortRateModelHandle_constraint", _wrap_ShortRateModelHandle_constraint, METH_O, NULL},
	 { "ShortRateModelHandle_endCriteria", _wrap_ShortRateModelHandle_endCriteria, METH_O, NULL},
	 { "ShortRateModelHandle_problemValues", _wrap_ShortRateModelHandle_problemValues, METH_O, NULL},
	 { "ShortRateModelHandle_functionEvaluation", _wrap_ShortRateModelHandle_functionEvaluation, METH_O, NULL},
	 { "ShortRateModelHandle_swigregister", ShortRateModelHandle_swigregister, METH_O, NULL},
	 { "ShortRateModelHandle_swiginit", ShortRateModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableShortRateModelHandle", _wrap_new_RelinkableShortRateModelHandle, METH_VARARGS, NULL},
	 { "RelinkableShortRateModelHandle_linkTo", _wrap_RelinkableShortRateModelHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableShortRateModelHandle_reset", _wrap_RelinkableShortRateModelHandle_reset, METH_O, NULL},
	 { "delete_RelinkableShortRateModelHandle", _wrap_delete_RelinkableShortRateModelHandle, METH_O, NULL},
	 { "RelinkableShortRateModelHandle_swigregister", RelinkableShortRateModelHandle_swigregister, METH_O, NULL},
	 { "RelinkableShortRateModelHandle_swiginit", RelinkableShortRateModelHandle_swiginit, METH_VARARGS, NULL},
	 { "OneFactorAffineModel_discountBond", _wrap_OneFactorAffineModel_discountBond, METH_VARARGS, NULL},
	 { "OneFactorAffineModel_discount", _wrap_OneFactorAffineModel_discount, METH_VARARGS, NULL},
	 { "delete_OneFactorAffineModel", _wrap_delete_OneFactorAffineModel, METH_O, NULL},
	 { "OneFactorAffineModel_swigregister", OneFactorAffineModel_swigregister, METH_O, NULL},
	 { "new_Vasicek", _wrap_new_Vasicek, METH_VARARGS, NULL},
	 { "delete_Vasicek", _wrap_delete_Vasicek, METH_O, NULL},
	 { "Vasicek_swigregister", Vasicek_swigregister, METH_O, NULL},
	 { "Vasicek_swiginit", Vasicek_swiginit, METH_VARARGS, NULL},
	 { "new_HullWhite", _wrap_new_HullWhite, METH_VARARGS, NULL},
	 { "HullWhite_convexityBias", _wrap_HullWhite_convexityBias, METH_VARARGS, NULL},
	 { "HullWhite_termStructure", _wrap_HullWhite_termStructure, METH_O, NULL},
	 { "delete_HullWhite", _wrap_delete_HullWhite, METH_O, NULL},
	 { "HullWhite_swigregister", HullWhite_swigregister, METH_O, NULL},
	 { "HullWhite_swiginit", HullWhite_swiginit, METH_VARARGS, NULL},
	 { "new_BlackKarasinski", _wrap_new_BlackKarasinski, METH_VARARGS, NULL},
	 { "BlackKarasinski_termStructure", _wrap_BlackKarasinski_termStructure, METH_O, NULL},
	 { "delete_BlackKarasinski", _wrap_delete_BlackKarasinski, METH_O, NULL},
	 { "BlackKarasinski_swigregister", BlackKarasinski_swigregister, METH_O, NULL},
	 { "BlackKarasinski_swiginit", BlackKarasinski_swiginit, METH_VARARGS, NULL},
	 { "new_CoxIngersollRoss", _wrap_new_CoxIngersollRoss, METH_VARARGS, NULL},
	 { "CoxIngersollRoss_discount", _wrap_CoxIngersollRoss_discount, METH_VARARGS, NULL},
	 { "delete_CoxIngersollRoss", _wrap_delete_CoxIngersollRoss, METH_O, NULL},
	 { "CoxIngersollRoss_swigregister", CoxIngersollRoss_swigregister, METH_O, NULL},
	 { "CoxIngersollRoss_swiginit", CoxIngersollRoss_swiginit, METH_VARARGS, NULL},
	 { "new_ExtendedCoxIngersollRoss", _wrap_new_ExtendedCoxIngersollRoss, METH_VARARGS, NULL},
	 { "ExtendedCoxIngersollRoss_discount", _wrap_ExtendedCoxIngersollRoss_discount, METH_VARARGS, NULL},
	 { "delete_ExtendedCoxIngersollRoss", _wrap_delete_ExtendedCoxIngersollRoss, METH_O, NULL},
	 { "ExtendedCoxIngersollRoss_swigregister", ExtendedCoxIngersollRoss_swigregister, METH_O, NULL},
	 { "ExtendedCoxIngersollRoss_swiginit", ExtendedCoxIngersollRoss_swiginit, METH_VARARGS, NULL},
	 { "new_G2", _wrap_new_G2, METH_VARARGS, NULL},
	 { "G2_termStructure", _wrap_G2_termStructure, METH_O, NULL},
	 { "delete_G2", _wrap_delete_G2, METH_O, NULL},
	 { "G2_swigregister", G2_swigregister, METH_O, NULL},
	 { "G2_swiginit", G2_swiginit, METH_VARARGS, NULL},
	 { "new_JamshidianSwaptionEngine", _wrap_new_JamshidianSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_JamshidianSwaptionEngine", _wrap_delete_JamshidianSwaptionEngine, METH_O, NULL},
	 { "JamshidianSwaptionEngine_swigregister", JamshidianSwaptionEngine_swigregister, METH_O, NULL},
	 { "JamshidianSwaptionEngine_swiginit", JamshidianSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_TreeSwaptionEngine", _wrap_new_TreeSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_TreeSwaptionEngine", _wrap_delete_TreeSwaptionEngine, METH_O, NULL},
	 { "TreeSwaptionEngine_swigregister", TreeSwaptionEngine_swigregister, METH_O, NULL},
	 { "TreeSwaptionEngine_swiginit", TreeSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticCapFloorEngine", _wrap_new_AnalyticCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_AnalyticCapFloorEngine", _wrap_delete_AnalyticCapFloorEngine, METH_O, NULL},
	 { "AnalyticCapFloorEngine_swigregister", AnalyticCapFloorEngine_swigregister, METH_O, NULL},
	 { "AnalyticCapFloorEngine_swiginit", AnalyticCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_TreeCapFloorEngine", _wrap_new_TreeCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_TreeCapFloorEngine", _wrap_delete_TreeCapFloorEngine, METH_O, NULL},
	 { "TreeCapFloorEngine_swigregister", TreeCapFloorEngine_swigregister, METH_O, NULL},
	 { "TreeCapFloorEngine_swiginit", TreeCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_G2SwaptionEngine", _wrap_new_G2SwaptionEngine, METH_VARARGS, NULL},
	 { "delete_G2SwaptionEngine", _wrap_delete_G2SwaptionEngine, METH_O, NULL},
	 { "G2SwaptionEngine_swigregister", G2SwaptionEngine_swigregister, METH_O, NULL},
	 { "G2SwaptionEngine_swiginit", G2SwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdG2SwaptionEngine", _wrap_new_FdG2SwaptionEngine, METH_VARARGS, NULL},
	 { "delete_FdG2SwaptionEngine", _wrap_delete_FdG2SwaptionEngine, METH_O, NULL},
	 { "FdG2SwaptionEngine_swigregister", FdG2SwaptionEngine_swigregister, METH_O, NULL},
	 { "FdG2SwaptionEngine_swiginit", FdG2SwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHullWhiteSwaptionEngine", _wrap_new_FdHullWhiteSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_FdHullWhiteSwaptionEngine", _wrap_delete_FdHullWhiteSwaptionEngine, METH_O, NULL},
	 { "FdHullWhiteSwaptionEngine_swigregister", FdHullWhiteSwaptionEngine_swigregister, METH_O, NULL},
	 { "FdHullWhiteSwaptionEngine_swiginit", FdHullWhiteSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticBSMHullWhiteEngine", _wrap_new_AnalyticBSMHullWhiteEngine, METH_VARARGS, NULL},
	 { "delete_AnalyticBSMHullWhiteEngine", _wrap_delete_AnalyticBSMHullWhiteEngine, METH_O, NULL},
	 { "AnalyticBSMHullWhiteEngine_swigregister", AnalyticBSMHullWhiteEngine_swigregister, METH_O, NULL},
	 { "AnalyticBSMHullWhiteEngine_swiginit", AnalyticBSMHullWhiteEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Bond", _wrap_new_Bond, METH_VARARGS, NULL},
	 { "Bond_nextCouponRate", _wrap_Bond_nextCouponRate, METH_VARARGS, NULL},
	 { "Bond_previousCouponRate", _wrap_Bond_previousCouponRate, METH_VARARGS, NULL},
	 { "Bond_settlementDays", _wrap_Bond_settlementDays, METH_O, NULL},
	 { "Bond_settlementDate", _wrap_Bond_settlementDate, METH_VARARGS, NULL},
	 { "Bond_startDate", _wrap_Bond_startDate, METH_O, NULL},
	 { "Bond_maturityDate", _wrap_Bond_maturityDate, METH_O, NULL},
	 { "Bond_issueDate", _wrap_Bond_issueDate, METH_O, NULL},
	 { "Bond_cashflows", _wrap_Bond_cashflows, METH_O, NULL},
	 { "Bond_redemptions", _wrap_Bond_redemptions, METH_O, NULL},
	 { "Bond_redemption", _wrap_Bond_redemption, METH_O, NULL},
	 { "Bond_calendar", _wrap_Bond_calendar, METH_O, NULL},
	 { "Bond_notionals", _wrap_Bond_notionals, METH_O, NULL},
	 { "Bond_notional", _wrap_Bond_notional, METH_VARARGS, NULL},
	 { "Bond_cleanPrice", _wrap_Bond_cleanPrice, METH_VARARGS, NULL},
	 { "Bond_dirtyPrice", _wrap_Bond_dirtyPrice, METH_VARARGS, NULL},
	 { "Bond_bondYield", _wrap_Bond_bondYield, METH_VARARGS, NULL},
	 { "Bond_accruedAmount", _wrap_Bond_accruedAmount, METH_VARARGS, NULL},
	 { "Bond_settlementValue", _wrap_Bond_settlementValue, METH_VARARGS, NULL},
	 { "delete_Bond", _wrap_delete_Bond, METH_O, NULL},
	 { "Bond_swigregister", Bond_swigregister, METH_O, NULL},
	 { "Bond_swiginit", Bond_swiginit, METH_VARARGS, NULL},
	 { "cleanPriceFromZSpread", _wrap_cleanPriceFromZSpread, METH_VARARGS, NULL},
	 { "new_ZeroCouponBond", (PyCFunction)(void(*)(void))_wrap_new_ZeroCouponBond, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_ZeroCouponBond", _wrap_delete_ZeroCouponBond, METH_O, NULL},
	 { "ZeroCouponBond_swigregister", ZeroCouponBond_swigregister, METH_O, NULL},
	 { "ZeroCouponBond_swiginit", ZeroCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_FixedRateBond", _wrap_new_FixedRateBond, METH_VARARGS, NULL},
	 { "FixedRateBond_from_rates", (PyCFunction)(void(*)(void))_wrap_FixedRateBond_from_rates, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "FixedRateBond_from_interest_rates", (PyCFunction)(void(*)(void))_wrap_FixedRateBond_from_interest_rates, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "FixedRateBond_from_date_info", (PyCFunction)(void(*)(void))_wrap_FixedRateBond_from_date_info, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "FixedRateBond_frequency", _wrap_FixedRateBond_frequency, METH_O, NULL},
	 { "FixedRateBond_dayCounter", _wrap_FixedRateBond_dayCounter, METH_O, NULL},
	 { "delete_FixedRateBond", _wrap_delete_FixedRateBond, METH_O, NULL},
	 { "FixedRateBond_swigregister", FixedRateBond_swigregister, METH_O, NULL},
	 { "FixedRateBond_swiginit", FixedRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_AmortizingFixedRateBond", _wrap_new_AmortizingFixedRateBond, METH_VARARGS, NULL},
	 { "AmortizingFixedRateBond_frequency", _wrap_AmortizingFixedRateBond_frequency, METH_O, NULL},
	 { "AmortizingFixedRateBond_dayCounter", _wrap_AmortizingFixedRateBond_dayCounter, METH_O, NULL},
	 { "delete_AmortizingFixedRateBond", _wrap_delete_AmortizingFixedRateBond, METH_O, NULL},
	 { "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, NULL},
	 { "delete_AmortizingFloatingRateBond", _wrap_delete_AmortizingFloatingRateBond, METH_O, NULL},
	 { "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, NULL},
	 { "delete_FloatingRateBond", _wrap_delete_FloatingRateBond, METH_O, NULL},
	 { "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, NULL},
	 { "delete_CmsRateBond", _wrap_delete_CmsRateBond, METH_O, NULL},
	 { "CmsRateBond_swigregister", CmsRateBond_swigregister, METH_O, NULL},
	 { "CmsRateBond_swiginit", CmsRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_DiscountingBondEngine", _wrap_new_DiscountingBondEngine, METH_O, NULL},
	 { "delete_DiscountingBondEngine", _wrap_delete_DiscountingBondEngine, METH_O, NULL},
	 { "DiscountingBondEngine_swigregister", DiscountingBondEngine_swigregister, METH_O, NULL},
	 { "DiscountingBondEngine_swiginit", DiscountingBondEngine_swiginit, METH_VARARGS, NULL},
	 { "CallableBond_callability", _wrap_CallableBond_callability, METH_O, NULL},
	 { "CallableBond_impliedVolatility", _wrap_CallableBond_impliedVolatility, METH_VARARGS, NULL},
	 { "CallableBond_OAS", _wrap_CallableBond_OAS, METH_VARARGS, NULL},
	 { "CallableBond_cleanPriceOAS", _wrap_CallableBond_cleanPriceOAS, METH_VARARGS, NULL},
	 { "CallableBond_effectiveDuration", _wrap_CallableBond_effectiveDuration, METH_VARARGS, NULL},
	 { "CallableBond_effectiveConvexity", _wrap_CallableBond_effectiveConvexity, METH_VARARGS, NULL},
	 { "delete_CallableBond", _wrap_delete_CallableBond, METH_O, NULL},
	 { "CallableBond_swigregister", CallableBond_swigregister, METH_O, NULL},
	 { "new_CallableFixedRateBond", (PyCFunction)(void(*)(void))_wrap_new_CallableFixedRateBond, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_CallableFixedRateBond", _wrap_delete_CallableFixedRateBond, METH_O, NULL},
	 { "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, NULL},
	 { "delete_CallableZeroCouponBond", _wrap_delete_CallableZeroCouponBond, METH_O, NULL},
	 { "CallableZeroCouponBond_swigregister", CallableZeroCouponBond_swigregister, METH_O, NULL},
	 { "CallableZeroCouponBond_swiginit", CallableZeroCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_TreeCallableFixedRateBondEngine", _wrap_new_TreeCallableFixedRateBondEngine, METH_VARARGS, NULL},
	 { "delete_TreeCallableFixedRateBondEngine", _wrap_delete_TreeCallableFixedRateBondEngine, METH_O, NULL},
	 { "TreeCallableFixedRateBondEngine_swigregister", TreeCallableFixedRateBondEngine_swigregister, METH_O, NULL},
	 { "TreeCallableFixedRateBondEngine_swiginit", TreeCallableFixedRateBondEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCallableFixedRateBondEngine", _wrap_new_BlackCallableFixedRateBondEngine, METH_VARARGS, NULL},
	 { "delete_BlackCallableFixedRateBondEngine", _wrap_delete_BlackCallableFixedRateBondEngine, METH_O, NULL},
	 { "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, NULL},
	 { "delete_CPIBond", _wrap_delete_CPIBond, METH_O, NULL},
	 { "CPIBond_swigregister", CPIBond_swigregister, METH_O, NULL},
	 { "CPIBond_swiginit", CPIBond_swiginit, METH_VARARGS, NULL},
	 { "BondFunctions_startDate", _wrap_BondFunctions_startDate, METH_O, NULL},
	 { "BondFunctions_maturityDate", _wrap_BondFunctions_maturityDate, METH_O, NULL},
	 { "BondFunctions_isTradable", _wrap_BondFunctions_isTradable, METH_VARARGS, NULL},
	 { "BondFunctions_previousCashFlowDate", _wrap_BondFunctions_previousCashFlowDate, METH_VARARGS, NULL},
	 { "BondFunctions_nextCashFlowDate", _wrap_BondFunctions_nextCashFlowDate, METH_VARARGS, NULL},
	 { "BondFunctions_previousCashFlowAmount", _wrap_BondFunctions_previousCashFlowAmount, METH_VARARGS, NULL},
	 { "BondFunctions_nextCashFlowAmount", _wrap_BondFunctions_nextCashFlowAmount, METH_VARARGS, NULL},
	 { "BondFunctions_previousCouponRate", _wrap_BondFunctions_previousCouponRate, METH_VARARGS, NULL},
	 { "BondFunctions_nextCouponRate", _wrap_BondFunctions_nextCouponRate, METH_VARARGS, NULL},
	 { "BondFunctions_accrualStartDate", _wrap_BondFunctions_accrualStartDate, METH_VARARGS, NULL},
	 { "BondFunctions_accrualEndDate", _wrap_BondFunctions_accrualEndDate, METH_VARARGS, NULL},
	 { "BondFunctions_accrualPeriod", _wrap_BondFunctions_accrualPeriod, METH_VARARGS, NULL},
	 { "BondFunctions_accrualDays", _wrap_BondFunctions_accrualDays, METH_VARARGS, NULL},
	 { "BondFunctions_accruedPeriod", _wrap_BondFunctions_accruedPeriod, METH_VARARGS, NULL},
	 { "BondFunctions_accruedDays", _wrap_BondFunctions_accruedDays, METH_VARARGS, NULL},
	 { "BondFunctions_accruedAmount", _wrap_BondFunctions_accruedAmount, METH_VARARGS, NULL},
	 { "BondFunctions_atmRate", _wrap_BondFunctions_atmRate, METH_VARARGS, NULL},
	 { "BondFunctions_cleanPrice", _wrap_BondFunctions_cleanPrice, METH_VARARGS, NULL},
	 { "BondFunctions_bps", _wrap_BondFunctions_bps, METH_VARARGS, NULL},
	 { "BondFunctions_bondYield", _wrap_BondFunctions_bondYield, METH_VARARGS, NULL},
	 { "BondFunctions_duration", _wrap_BondFunctions_duration, METH_VARARGS, NULL},
	 { "BondFunctions_convexity", _wrap_BondFunctions_convexity, METH_VARARGS, NULL},
	 { "BondFunctions_basisPointValue", _wrap_BondFunctions_basisPointValue, METH_VARARGS, NULL},
	 { "BondFunctions_yieldValueBasisPoint", _wrap_BondFunctions_yieldValueBasisPoint, METH_VARARGS, NULL},
	 { "BondFunctions_zSpread", _wrap_BondFunctions_zSpread, METH_VARARGS, NULL},
	 { "BondFunctions_yieldBrent", _wrap_BondFunctions_yieldBrent, METH_VARARGS, NULL},
	 { "BondFunctions_yieldBisection", _wrap_BondFunctions_yieldBisection, METH_VARARGS, NULL},
	 { "BondFunctions_yieldFalsePosition", _wrap_BondFunctions_yieldFalsePosition, METH_VARARGS, NULL},
	 { "BondFunctions_yieldRidder", _wrap_BondFunctions_yieldRidder, METH_VARARGS, NULL},
	 { "BondFunctions_yieldSecant", _wrap_BondFunctions_yieldSecant, METH_VARARGS, NULL},
	 { "BondFunctions_yieldNewton", _wrap_BondFunctions_yieldNewton, METH_VARARGS, NULL},
	 { "BondFunctions_yieldNewtonSafe", _wrap_BondFunctions_yieldNewtonSafe, METH_VARARGS, NULL},
	 { "new_BondFunctions", _wrap_new_BondFunctions, METH_NOARGS, NULL},
	 { "delete_BondFunctions", _wrap_delete_BondFunctions, METH_O, NULL},
	 { "BondFunctions_swigregister", BondFunctions_swigregister, METH_O, NULL},
	 { "BondFunctions_swiginit", BondFunctions_swiginit, METH_VARARGS, NULL},
	 { "CapFloor_impliedVolatility", _wrap_CapFloor_impliedVolatility, METH_VARARGS, NULL},
	 { "CapFloor_floatingLeg", _wrap_CapFloor_floatingLeg, METH_O, NULL},
	 { "CapFloor_capRates", _wrap_CapFloor_capRates, METH_O, NULL},
	 { "CapFloor_floorRates", _wrap_CapFloor_floorRates, METH_O, NULL},
	 { "CapFloor_startDate", _wrap_CapFloor_startDate, METH_O, NULL},
	 { "CapFloor_maturityDate", _wrap_CapFloor_maturityDate, METH_O, NULL},
	 { "CapFloor_type", _wrap_CapFloor_type, METH_O, NULL},
	 { "CapFloor_atmRate", _wrap_CapFloor_atmRate, METH_VARARGS, NULL},
	 { "CapFloor_vega", _wrap_CapFloor_vega, METH_O, NULL},
	 { "CapFloor_optionletsPrice", _wrap_CapFloor_optionletsPrice, METH_O, NULL},
	 { "CapFloor_optionletsVega", _wrap_CapFloor_optionletsVega, METH_O, NULL},
	 { "CapFloor_optionletsDelta", _wrap_CapFloor_optionletsDelta, METH_O, NULL},
	 { "CapFloor_optionletsDiscountFactor", _wrap_CapFloor_optionletsDiscountFactor, METH_O, NULL},
	 { "CapFloor_optionletsAtmForward", _wrap_CapFloor_optionletsAtmForward, METH_O, NULL},
	 { "CapFloor_optionletsStdDev", _wrap_CapFloor_optionletsStdDev, METH_O, NULL},
	 { "delete_CapFloor", _wrap_delete_CapFloor, METH_O, NULL},
	 { "CapFloor_swigregister", CapFloor_swigregister, METH_O, NULL},
	 { "new_Cap", _wrap_new_Cap, METH_VARARGS, NULL},
	 { "delete_Cap", _wrap_delete_Cap, METH_O, NULL},
	 { "Cap_swigregister", Cap_swigregister, METH_O, NULL},
	 { "Cap_swiginit", Cap_swiginit, METH_VARARGS, NULL},
	 { "new_Floor", _wrap_new_Floor, METH_VARARGS, NULL},
	 { "delete_Floor", _wrap_delete_Floor, METH_O, NULL},
	 { "Floor_swigregister", Floor_swigregister, METH_O, NULL},
	 { "Floor_swiginit", Floor_swiginit, METH_VARARGS, NULL},
	 { "new_Collar", _wrap_new_Collar, METH_VARARGS, NULL},
	 { "delete_Collar", _wrap_delete_Collar, METH_O, NULL},
	 { "Collar_swigregister", Collar_swigregister, METH_O, NULL},
	 { "Collar_swiginit", Collar_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCapFloorEngine", _wrap_new_BlackCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_BlackCapFloorEngine", _wrap_delete_BlackCapFloorEngine, METH_O, NULL},
	 { "BlackCapFloorEngine_swigregister", BlackCapFloorEngine_swigregister, METH_O, NULL},
	 { "BlackCapFloorEngine_swiginit", BlackCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BachelierCapFloorEngine", _wrap_new_BachelierCapFloorEngine, METH_VARARGS, NULL},
	 { "delete_BachelierCapFloorEngine", _wrap_delete_BachelierCapFloorEngine, METH_O, NULL},
	 { "BachelierCapFloorEngine_swigregister", BachelierCapFloorEngine_swigregister, METH_O, NULL},
	 { "BachelierCapFloorEngine_swiginit", BachelierCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "delete_Dividend", _wrap_delete_Dividend, METH_O, NULL},
	 { "Dividend_swigregister", Dividend_swigregister, METH_O, NULL},
	 { "new_FixedDividend", _wrap_new_FixedDividend, METH_VARARGS, NULL},
	 { "delete_FixedDividend", _wrap_delete_FixedDividend, METH_O, NULL},
	 { "FixedDividend_swigregister", FixedDividend_swigregister, METH_O, NULL},
	 { "FixedDividend_swiginit", FixedDividend_swiginit, METH_VARARGS, NULL},
	 { "new_FractionalDividend", _wrap_new_FractionalDividend, METH_VARARGS, NULL},
	 { "delete_FractionalDividend", _wrap_delete_FractionalDividend, METH_O, NULL},
	 { "FractionalDividend_swigregister", FractionalDividend_swigregister, METH_O, NULL},
	 { "FractionalDividend_swiginit", FractionalDividend_swiginit, METH_VARARGS, NULL},
	 { "DividendSchedule_iterator", _wrap_DividendSchedule_iterator, METH_O, NULL},
	 { "DividendSchedule___nonzero__", _wrap_DividendSchedule___nonzero__, METH_O, NULL},
	 { "DividendSchedule___bool__", _wrap_DividendSchedule___bool__, METH_O, NULL},
	 { "DividendSchedule___len__", _wrap_DividendSchedule___len__, METH_O, NULL},
	 { "DividendSchedule___getslice__", _wrap_DividendSchedule___getslice__, METH_VARARGS, NULL},
	 { "DividendSchedule___setslice__", _wrap_DividendSchedule___setslice__, METH_VARARGS, NULL},
	 { "DividendSchedule___delslice__", _wrap_DividendSchedule___delslice__, METH_VARARGS, NULL},
	 { "DividendSchedule___delitem__", _wrap_DividendSchedule___delitem__, METH_VARARGS, NULL},
	 { "DividendSchedule___getitem__", _wrap_DividendSchedule___getitem__, METH_VARARGS, NULL},
	 { "DividendSchedule___setitem__", _wrap_DividendSchedule___setitem__, METH_VARARGS, NULL},
	 { "DividendSchedule_pop", _wrap_DividendSchedule_pop, METH_O, NULL},
	 { "DividendSchedule_append", _wrap_DividendSchedule_append, METH_VARARGS, NULL},
	 { "DividendSchedule_empty", _wrap_DividendSchedule_empty, METH_O, NULL},
	 { "DividendSchedule_size", _wrap_DividendSchedule_size, METH_O, NULL},
	 { "DividendSchedule_swap", _wrap_DividendSchedule_swap, METH_VARARGS, NULL},
	 { "DividendSchedule_begin", _wrap_DividendSchedule_begin, METH_O, NULL},
	 { "DividendSchedule_end", _wrap_DividendSchedule_end, METH_O, NULL},
	 { "DividendSchedule_rbegin", _wrap_DividendSchedule_rbegin, METH_O, NULL},
	 { "DividendSchedule_rend", _wrap_DividendSchedule_rend, METH_O, NULL},
	 { "DividendSchedule_clear", _wrap_DividendSchedule_clear, METH_O, NULL},
	 { "DividendSchedule_get_allocator", _wrap_DividendSchedule_get_allocator, METH_O, NULL},
	 { "DividendSchedule_pop_back", _wrap_DividendSchedule_pop_back, METH_O, NULL},
	 { "DividendSchedule_erase", _wrap_DividendSchedule_erase, METH_VARARGS, NULL},
	 { "new_DividendSchedule", _wrap_new_DividendSchedule, METH_VARARGS, NULL},
	 { "DividendSchedule_push_back", _wrap_DividendSchedule_push_back, METH_VARARGS, NULL},
	 { "DividendSchedule_front", _wrap_DividendSchedule_front, METH_O, NULL},
	 { "DividendSchedule_back", _wrap_DividendSchedule_back, METH_O, NULL},
	 { "DividendSchedule_assign", _wrap_DividendSchedule_assign, METH_VARARGS, NULL},
	 { "DividendSchedule_resize", _wrap_DividendSchedule_resize, METH_VARARGS, NULL},
	 { "DividendSchedule_insert", _wrap_DividendSchedule_insert, METH_VARARGS, NULL},
	 { "DividendSchedule_reserve", _wrap_DividendSchedule_reserve, METH_VARARGS, NULL},
	 { "DividendSchedule_capacity", _wrap_DividendSchedule_capacity, METH_O, NULL},
	 { "delete_DividendSchedule", _wrap_delete_DividendSchedule, METH_O, NULL},
	 { "DividendSchedule_swigregister", DividendSchedule_swigregister, METH_O, NULL},
	 { "DividendSchedule_swiginit", DividendSchedule_swiginit, METH_VARARGS, NULL},
	 { "new_ConvertibleZeroCouponBond", _wrap_new_ConvertibleZeroCouponBond, METH_VARARGS, NULL},
	 { "delete_ConvertibleZeroCouponBond", _wrap_delete_ConvertibleZeroCouponBond, METH_O, NULL},
	 { "ConvertibleZeroCouponBond_swigregister", ConvertibleZeroCouponBond_swigregister, METH_O, NULL},
	 { "ConvertibleZeroCouponBond_swiginit", ConvertibleZeroCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_ConvertibleFixedCouponBond", _wrap_new_ConvertibleFixedCouponBond, METH_VARARGS, NULL},
	 { "delete_ConvertibleFixedCouponBond", _wrap_delete_ConvertibleFixedCouponBond, METH_O, NULL},
	 { "ConvertibleFixedCouponBond_swigregister", ConvertibleFixedCouponBond_swigregister, METH_O, NULL},
	 { "ConvertibleFixedCouponBond_swiginit", ConvertibleFixedCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_ConvertibleFloatingRateBond", _wrap_new_ConvertibleFloatingRateBond, METH_VARARGS, NULL},
	 { "delete_ConvertibleFloatingRateBond", _wrap_delete_ConvertibleFloatingRateBond, METH_O, NULL},
	 { "ConvertibleFloatingRateBond_swigregister", ConvertibleFloatingRateBond_swigregister, METH_O, NULL},
	 { "ConvertibleFloatingRateBond_swiginit", ConvertibleFloatingRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRConvertibleEngine", _wrap_new_BinomialCRRConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialCRRConvertibleEngine", _wrap_delete_BinomialCRRConvertibleEngine, METH_O, NULL},
	 { "BinomialCRRConvertibleEngine_swigregister", BinomialCRRConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRConvertibleEngine_swiginit", BinomialCRRConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRConvertibleEngine", _wrap_new_BinomialJRConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialJRConvertibleEngine", _wrap_delete_BinomialJRConvertibleEngine, METH_O, NULL},
	 { "BinomialJRConvertibleEngine_swigregister", BinomialJRConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialJRConvertibleEngine_swiginit", BinomialJRConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPConvertibleEngine", _wrap_new_BinomialEQPConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialEQPConvertibleEngine", _wrap_delete_BinomialEQPConvertibleEngine, METH_O, NULL},
	 { "BinomialEQPConvertibleEngine_swigregister", BinomialEQPConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPConvertibleEngine_swiginit", BinomialEQPConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisConvertibleEngine", _wrap_new_BinomialTrigeorgisConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialTrigeorgisConvertibleEngine", _wrap_delete_BinomialTrigeorgisConvertibleEngine, METH_O, NULL},
	 { "BinomialTrigeorgisConvertibleEngine_swigregister", BinomialTrigeorgisConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisConvertibleEngine_swiginit", BinomialTrigeorgisConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianConvertibleEngine", _wrap_new_BinomialTianConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialTianConvertibleEngine", _wrap_delete_BinomialTianConvertibleEngine, METH_O, NULL},
	 { "BinomialTianConvertibleEngine_swigregister", BinomialTianConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialTianConvertibleEngine_swiginit", BinomialTianConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRConvertibleEngine", _wrap_new_BinomialLRConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialLRConvertibleEngine", _wrap_delete_BinomialLRConvertibleEngine, METH_O, NULL},
	 { "BinomialLRConvertibleEngine_swigregister", BinomialLRConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialLRConvertibleEngine_swiginit", BinomialLRConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4ConvertibleEngine", _wrap_new_BinomialJ4ConvertibleEngine, METH_VARARGS, NULL},
	 { "delete_BinomialJ4ConvertibleEngine", _wrap_delete_BinomialJ4ConvertibleEngine, METH_O, NULL},
	 { "BinomialJ4ConvertibleEngine_swigregister", BinomialJ4ConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4ConvertibleEngine_swiginit", BinomialJ4ConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Futures", _wrap_new_Futures, METH_NOARGS, NULL},
	 { "delete_Futures", _wrap_delete_Futures, METH_O, NULL},
	 { "Futures_swigregister", Futures_swigregister, METH_O, NULL},
	 { "Futures_swiginit", Futures_swiginit, METH_VARARGS, NULL},
	 { "delete_OvernightIndexFuture", _wrap_delete_OvernightIndexFuture, METH_O, NULL},
	 { "OvernightIndexFuture_swigregister", OvernightIndexFuture_swigregister, METH_O, NULL},
	 { "new_Pillar", _wrap_new_Pillar, METH_NOARGS, NULL},
	 { "delete_Pillar", _wrap_delete_Pillar, METH_O, NULL},
	 { "Pillar_swigregister", Pillar_swigregister, METH_O, NULL},
	 { "Pillar_swiginit", Pillar_swiginit, METH_VARARGS, NULL},
	 { "RateHelper_quote", _wrap_RateHelper_quote, METH_O, NULL},
	 { "RateHelper_latestDate", _wrap_RateHelper_latestDate, METH_O, NULL},
	 { "RateHelper_earliestDate", _wrap_RateHelper_earliestDate, METH_O, NULL},
	 { "RateHelper_maturityDate", _wrap_RateHelper_maturityDate, METH_O, NULL},
	 { "RateHelper_latestRelevantDate", _wrap_RateHelper_latestRelevantDate, METH_O, NULL},
	 { "RateHelper_pillarDate", _wrap_RateHelper_pillarDate, METH_O, NULL},
	 { "RateHelper_impliedQuote", _wrap_RateHelper_impliedQuote, METH_O, NULL},
	 { "RateHelper_quoteError", _wrap_RateHelper_quoteError, METH_O, NULL},
	 { "delete_RateHelper", _wrap_delete_RateHelper, METH_O, NULL},
	 { "RateHelper_swigregister", RateHelper_swigregister, METH_O, NULL},
	 { "new_DepositRateHelper", _wrap_new_DepositRateHelper, METH_VARARGS, NULL},
	 { "delete_DepositRateHelper", _wrap_delete_DepositRateHelper, METH_O, NULL},
	 { "DepositRateHelper_swigregister", DepositRateHelper_swigregister, METH_O, NULL},
	 { "DepositRateHelper_swiginit", DepositRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FraRateHelper", _wrap_new_FraRateHelper, METH_VARARGS, NULL},
	 { "delete_FraRateHelper", _wrap_delete_FraRateHelper, METH_O, NULL},
	 { "FraRateHelper_swigregister", FraRateHelper_swigregister, METH_O, NULL},
	 { "FraRateHelper_swiginit", FraRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FuturesRateHelper", _wrap_new_FuturesRateHelper, METH_VARARGS, NULL},
	 { "delete_FuturesRateHelper", _wrap_delete_FuturesRateHelper, METH_O, NULL},
	 { "FuturesRateHelper_swigregister", FuturesRateHelper_swigregister, METH_O, NULL},
	 { "FuturesRateHelper_swiginit", FuturesRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_SwapRateHelper", _wrap_new_SwapRateHelper, METH_VARARGS, NULL},
	 { "SwapRateHelper_spread", _wrap_SwapRateHelper_spread, METH_O, NULL},
	 { "SwapRateHelper_swap", _wrap_SwapRateHelper_swap, METH_O, NULL},
	 { "delete_SwapRateHelper", _wrap_delete_SwapRateHelper, METH_O, NULL},
	 { "SwapRateHelper_swigregister", SwapRateHelper_swigregister, METH_O, NULL},
	 { "SwapRateHelper_swiginit", SwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_BondHelper", _wrap_new_BondHelper, METH_VARARGS, NULL},
	 { "BondHelper_bond", _wrap_BondHelper_bond, METH_O, NULL},
	 { "delete_BondHelper", _wrap_delete_BondHelper, METH_O, NULL},
	 { "BondHelper_swigregister", BondHelper_swigregister, METH_O, NULL},
	 { "BondHelper_swiginit", BondHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FixedRateBondHelper", _wrap_new_FixedRateBondHelper, METH_VARARGS, NULL},
	 { "FixedRateBondHelper_fixedRateBond", _wrap_FixedRateBondHelper_fixedRateBond, METH_O, NULL},
	 { "delete_FixedRateBondHelper", _wrap_delete_FixedRateBondHelper, METH_O, NULL},
	 { "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, NULL},
	 { "OISRateHelper_swap", _wrap_OISRateHelper_swap, METH_O, NULL},
	 { "delete_OISRateHelper", _wrap_delete_OISRateHelper, METH_O, NULL},
	 { "OISRateHelper_swigregister", OISRateHelper_swigregister, METH_O, NULL},
	 { "OISRateHelper_swiginit", OISRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_DatedOISRateHelper", _wrap_new_DatedOISRateHelper, METH_VARARGS, NULL},
	 { "delete_DatedOISRateHelper", _wrap_delete_DatedOISRateHelper, METH_O, NULL},
	 { "DatedOISRateHelper_swigregister", DatedOISRateHelper_swigregister, METH_O, NULL},
	 { "DatedOISRateHelper_swiginit", DatedOISRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FxSwapRateHelper", _wrap_new_FxSwapRateHelper, METH_VARARGS, NULL},
	 { "delete_FxSwapRateHelper", _wrap_delete_FxSwapRateHelper, METH_O, NULL},
	 { "FxSwapRateHelper_swigregister", FxSwapRateHelper_swigregister, METH_O, NULL},
	 { "FxSwapRateHelper_swiginit", FxSwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexFutureRateHelper", _wrap_new_OvernightIndexFutureRateHelper, METH_VARARGS, NULL},
	 { "delete_OvernightIndexFutureRateHelper", _wrap_delete_OvernightIndexFutureRateHelper, METH_O, NULL},
	 { "OvernightIndexFutureRateHelper_swigregister", OvernightIndexFutureRateHelper_swigregister, METH_O, NULL},
	 { "OvernightIndexFutureRateHelper_swiginit", OvernightIndexFutureRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_SofrFutureRateHelper", _wrap_new_SofrFutureRateHelper, METH_VARARGS, NULL},
	 { "delete_SofrFutureRateHelper", _wrap_delete_SofrFutureRateHelper, METH_O, NULL},
	 { "SofrFutureRateHelper_swigregister", SofrFutureRateHelper_swigregister, METH_O, NULL},
	 { "SofrFutureRateHelper_swiginit", SofrFutureRateHelper_swiginit, METH_VARARGS, NULL},
	 { "RateHelperVector_iterator", _wrap_RateHelperVector_iterator, METH_O, NULL},
	 { "RateHelperVector___nonzero__", _wrap_RateHelperVector___nonzero__, METH_O, NULL},
	 { "RateHelperVector___bool__", _wrap_RateHelperVector___bool__, METH_O, NULL},
	 { "RateHelperVector___len__", _wrap_RateHelperVector___len__, METH_O, NULL},
	 { "RateHelperVector___getslice__", _wrap_RateHelperVector___getslice__, METH_VARARGS, NULL},
	 { "RateHelperVector___setslice__", _wrap_RateHelperVector___setslice__, METH_VARARGS, NULL},
	 { "RateHelperVector___delslice__", _wrap_RateHelperVector___delslice__, METH_VARARGS, NULL},
	 { "RateHelperVector___delitem__", _wrap_RateHelperVector___delitem__, METH_VARARGS, NULL},
	 { "RateHelperVector___getitem__", _wrap_RateHelperVector___getitem__, METH_VARARGS, NULL},
	 { "RateHelperVector___setitem__", _wrap_RateHelperVector___setitem__, METH_VARARGS, NULL},
	 { "RateHelperVector_pop", _wrap_RateHelperVector_pop, METH_O, NULL},
	 { "RateHelperVector_append", _wrap_RateHelperVector_append, METH_VARARGS, NULL},
	 { "RateHelperVector_empty", _wrap_RateHelperVector_empty, METH_O, NULL},
	 { "RateHelperVector_size", _wrap_RateHelperVector_size, METH_O, NULL},
	 { "RateHelperVector_swap", _wrap_RateHelperVector_swap, METH_VARARGS, NULL},
	 { "RateHelperVector_begin", _wrap_RateHelperVector_begin, METH_O, NULL},
	 { "RateHelperVector_end", _wrap_RateHelperVector_end, METH_O, NULL},
	 { "RateHelperVector_rbegin", _wrap_RateHelperVector_rbegin, METH_O, NULL},
	 { "RateHelperVector_rend", _wrap_RateHelperVector_rend, METH_O, NULL},
	 { "RateHelperVector_clear", _wrap_RateHelperVector_clear, METH_O, NULL},
	 { "RateHelperVector_get_allocator", _wrap_RateHelperVector_get_allocator, METH_O, NULL},
	 { "RateHelperVector_pop_back", _wrap_RateHelperVector_pop_back, METH_O, NULL},
	 { "RateHelperVector_erase", _wrap_RateHelperVector_erase, METH_VARARGS, NULL},
	 { "new_RateHelperVector", _wrap_new_RateHelperVector, METH_VARARGS, NULL},
	 { "RateHelperVector_push_back", _wrap_RateHelperVector_push_back, METH_VARARGS, NULL},
	 { "RateHelperVector_front", _wrap_RateHelperVector_front, METH_O, NULL},
	 { "RateHelperVector_back", _wrap_RateHelperVector_back, METH_O, NULL},
	 { "RateHelperVector_assign", _wrap_RateHelperVector_assign, METH_VARARGS, NULL},
	 { "RateHelperVector_resize", _wrap_RateHelperVector_resize, METH_VARARGS, NULL},
	 { "RateHelperVector_insert", _wrap_RateHelperVector_insert, METH_VARARGS, NULL},
	 { "RateHelperVector_reserve", _wrap_RateHelperVector_reserve, METH_VARARGS, NULL},
	 { "RateHelperVector_capacity", _wrap_RateHelperVector_capacity, METH_O, NULL},
	 { "delete_RateHelperVector", _wrap_delete_RateHelperVector, METH_O, NULL},
	 { "RateHelperVector_swigregister", RateHelperVector_swigregister, METH_O, NULL},
	 { "RateHelperVector_swiginit", RateHelperVector_swiginit, METH_VARARGS, NULL},
	 { "BondHelperVector_iterator", _wrap_BondHelperVector_iterator, METH_O, NULL},
	 { "BondHelperVector___nonzero__", _wrap_BondHelperVector___nonzero__, METH_O, NULL},
	 { "BondHelperVector___bool__", _wrap_BondHelperVector___bool__, METH_O, NULL},
	 { "BondHelperVector___len__", _wrap_BondHelperVector___len__, METH_O, NULL},
	 { "BondHelperVector___getslice__", _wrap_BondHelperVector___getslice__, METH_VARARGS, NULL},
	 { "BondHelperVector___setslice__", _wrap_BondHelperVector___setslice__, METH_VARARGS, NULL},
	 { "BondHelperVector___delslice__", _wrap_BondHelperVector___delslice__, METH_VARARGS, NULL},
	 { "BondHelperVector___delitem__", _wrap_BondHelperVector___delitem__, METH_VARARGS, NULL},
	 { "BondHelperVector___getitem__", _wrap_BondHelperVector___getitem__, METH_VARARGS, NULL},
	 { "BondHelperVector___setitem__", _wrap_BondHelperVector___setitem__, METH_VARARGS, NULL},
	 { "BondHelperVector_pop", _wrap_BondHelperVector_pop, METH_O, NULL},
	 { "BondHelperVector_append", _wrap_BondHelperVector_append, METH_VARARGS, NULL},
	 { "BondHelperVector_empty", _wrap_BondHelperVector_empty, METH_O, NULL},
	 { "BondHelperVector_size", _wrap_BondHelperVector_size, METH_O, NULL},
	 { "BondHelperVector_swap", _wrap_BondHelperVector_swap, METH_VARARGS, NULL},
	 { "BondHelperVector_begin", _wrap_BondHelperVector_begin, METH_O, NULL},
	 { "BondHelperVector_end", _wrap_BondHelperVector_end, METH_O, NULL},
	 { "BondHelperVector_rbegin", _wrap_BondHelperVector_rbegin, METH_O, NULL},
	 { "BondHelperVector_rend", _wrap_BondHelperVector_rend, METH_O, NULL},
	 { "BondHelperVector_clear", _wrap_BondHelperVector_clear, METH_O, NULL},
	 { "BondHelperVector_get_allocator", _wrap_BondHelperVector_get_allocator, METH_O, NULL},
	 { "BondHelperVector_pop_back", _wrap_BondHelperVector_pop_back, METH_O, NULL},
	 { "BondHelperVector_erase", _wrap_BondHelperVector_erase, METH_VARARGS, NULL},
	 { "new_BondHelperVector", _wrap_new_BondHelperVector, METH_VARARGS, NULL},
	 { "BondHelperVector_push_back", _wrap_BondHelperVector_push_back, METH_VARARGS, NULL},
	 { "BondHelperVector_front", _wrap_BondHelperVector_front, METH_O, NULL},
	 { "BondHelperVector_back", _wrap_BondHelperVector_back, METH_O, NULL},
	 { "BondHelperVector_assign", _wrap_BondHelperVector_assign, METH_VARARGS, NULL},
	 { "BondHelperVector_resize", _wrap_BondHelperVector_resize, METH_VARARGS, NULL},
	 { "BondHelperVector_insert", _wrap_BondHelperVector_insert, METH_VARARGS, NULL},
	 { "BondHelperVector_reserve", _wrap_BondHelperVector_reserve, METH_VARARGS, NULL},
	 { "BondHelperVector_capacity", _wrap_BondHelperVector_capacity, METH_O, NULL},
	 { "delete_BondHelperVector", _wrap_delete_BondHelperVector, METH_O, NULL},
	 { "BondHelperVector_swigregister", BondHelperVector_swigregister, METH_O, NULL},
	 { "BondHelperVector_swiginit", BondHelperVector_swiginit, METH_VARARGS, NULL},
	 { "as_depositratehelper", _wrap_as_depositratehelper, METH_O, NULL},
	 { "as_fraratehelper", _wrap_as_fraratehelper, METH_O, NULL},
	 { "as_swapratehelper", _wrap_as_swapratehelper, METH_O, NULL},
	 { "as_oisratehelper", _wrap_as_oisratehelper, METH_O, NULL},
	 { "new_Discount", _wrap_new_Discount, METH_NOARGS, NULL},
	 { "delete_Discount", _wrap_delete_Discount, METH_O, NULL},
	 { "Discount_swigregister", Discount_swigregister, METH_O, NULL},
	 { "Discount_swiginit", Discount_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroYield", _wrap_new_ZeroYield, METH_NOARGS, NULL},
	 { "delete_ZeroYield", _wrap_delete_ZeroYield, METH_O, NULL},
	 { "ZeroYield_swigregister", ZeroYield_swigregister, METH_O, NULL},
	 { "ZeroYield_swiginit", ZeroYield_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardRate", _wrap_new_ForwardRate, METH_NOARGS, NULL},
	 { "delete_ForwardRate", _wrap_delete_ForwardRate, METH_O, NULL},
	 { "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, NULL},
	 { "delete_IterativeBootstrap", _wrap_delete_IterativeBootstrap, METH_O, NULL},
	 { "IterativeBootstrap_swigregister", IterativeBootstrap_swigregister, METH_O, NULL},
	 { "IterativeBootstrap_swiginit", IterativeBootstrap_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseFlatForward", _wrap_new_PiecewiseFlatForward, METH_VARARGS, NULL},
	 { "PiecewiseFlatForward_dates", _wrap_PiecewiseFlatForward_dates, METH_O, NULL},
	 { "PiecewiseFlatForward_times", _wrap_PiecewiseFlatForward_times, METH_O, NULL},
	 { "PiecewiseFlatForward_nodes", _wrap_PiecewiseFlatForward_nodes, METH_O, NULL},
	 { "delete_PiecewiseFlatForward", _wrap_delete_PiecewiseFlatForward, METH_O, NULL},
	 { "PiecewiseFlatForward_swigregister", PiecewiseFlatForward_swigregister, METH_O, NULL},
	 { "PiecewiseFlatForward_swiginit", PiecewiseFlatForward_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLogLinearDiscount", _wrap_new_PiecewiseLogLinearDiscount, METH_VARARGS, NULL},
	 { "PiecewiseLogLinearDiscount_dates", _wrap_PiecewiseLogLinearDiscount_dates, METH_O, NULL},
	 { "PiecewiseLogLinearDiscount_times", _wrap_PiecewiseLogLinearDiscount_times, METH_O, NULL},
	 { "PiecewiseLogLinearDiscount_nodes", _wrap_PiecewiseLogLinearDiscount_nodes, METH_O, NULL},
	 { "delete_PiecewiseLogLinearDiscount", _wrap_delete_PiecewiseLogLinearDiscount, METH_O, NULL},
	 { "PiecewiseLogLinearDiscount_swigregister", PiecewiseLogLinearDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseLogLinearDiscount_swiginit", PiecewiseLogLinearDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLinearForward", _wrap_new_PiecewiseLinearForward, METH_VARARGS, NULL},
	 { "PiecewiseLinearForward_dates", _wrap_PiecewiseLinearForward_dates, METH_O, NULL},
	 { "PiecewiseLinearForward_times", _wrap_PiecewiseLinearForward_times, METH_O, NULL},
	 { "PiecewiseLinearForward_nodes", _wrap_PiecewiseLinearForward_nodes, METH_O, NULL},
	 { "delete_PiecewiseLinearForward", _wrap_delete_PiecewiseLinearForward, METH_O, NULL},
	 { "PiecewiseLinearForward_swigregister", PiecewiseLinearForward_swigregister, METH_O, NULL},
	 { "PiecewiseLinearForward_swiginit", PiecewiseLinearForward_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLinearZero", _wrap_new_PiecewiseLinearZero, METH_VARARGS, NULL},
	 { "PiecewiseLinearZero_dates", _wrap_PiecewiseLinearZero_dates, METH_O, NULL},
	 { "PiecewiseLinearZero_times", _wrap_PiecewiseLinearZero_times, METH_O, NULL},
	 { "PiecewiseLinearZero_nodes", _wrap_PiecewiseLinearZero_nodes, METH_O, NULL},
	 { "delete_PiecewiseLinearZero", _wrap_delete_PiecewiseLinearZero, METH_O, NULL},
	 { "PiecewiseLinearZero_swigregister", PiecewiseLinearZero_swigregister, METH_O, NULL},
	 { "PiecewiseLinearZero_swiginit", PiecewiseLinearZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseCubicZero", _wrap_new_PiecewiseCubicZero, METH_VARARGS, NULL},
	 { "PiecewiseCubicZero_dates", _wrap_PiecewiseCubicZero_dates, METH_O, NULL},
	 { "PiecewiseCubicZero_times", _wrap_PiecewiseCubicZero_times, METH_O, NULL},
	 { "PiecewiseCubicZero_nodes", _wrap_PiecewiseCubicZero_nodes, METH_O, NULL},
	 { "delete_PiecewiseCubicZero", _wrap_delete_PiecewiseCubicZero, METH_O, NULL},
	 { "PiecewiseCubicZero_swigregister", PiecewiseCubicZero_swigregister, METH_O, NULL},
	 { "PiecewiseCubicZero_swiginit", PiecewiseCubicZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLogCubicDiscount", _wrap_new_PiecewiseLogCubicDiscount, METH_VARARGS, NULL},
	 { "PiecewiseLogCubicDiscount_dates", _wrap_PiecewiseLogCubicDiscount_dates, METH_O, NULL},
	 { "PiecewiseLogCubicDiscount_times", _wrap_PiecewiseLogCubicDiscount_times, METH_O, NULL},
	 { "PiecewiseLogCubicDiscount_nodes", _wrap_PiecewiseLogCubicDiscount_nodes, METH_O, NULL},
	 { "delete_PiecewiseLogCubicDiscount", _wrap_delete_PiecewiseLogCubicDiscount, METH_O, NULL},
	 { "PiecewiseLogCubicDiscount_swigregister", PiecewiseLogCubicDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseLogCubicDiscount_swiginit", PiecewiseLogCubicDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseSplineCubicDiscount", _wrap_new_PiecewiseSplineCubicDiscount, METH_VARARGS, NULL},
	 { "PiecewiseSplineCubicDiscount_dates", _wrap_PiecewiseSplineCubicDiscount_dates, METH_O, NULL},
	 { "PiecewiseSplineCubicDiscount_times", _wrap_PiecewiseSplineCubicDiscount_times, METH_O, NULL},
	 { "PiecewiseSplineCubicDiscount_nodes", _wrap_PiecewiseSplineCubicDiscount_nodes, METH_O, NULL},
	 { "delete_PiecewiseSplineCubicDiscount", _wrap_delete_PiecewiseSplineCubicDiscount, METH_O, NULL},
	 { "PiecewiseSplineCubicDiscount_swigregister", PiecewiseSplineCubicDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseSplineCubicDiscount_swiginit", PiecewiseSplineCubicDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseKrugerZero", _wrap_new_PiecewiseKrugerZero, METH_VARARGS, NULL},
	 { "PiecewiseKrugerZero_dates", _wrap_PiecewiseKrugerZero_dates, METH_O, NULL},
	 { "PiecewiseKrugerZero_times", _wrap_PiecewiseKrugerZero_times, METH_O, NULL},
	 { "PiecewiseKrugerZero_nodes", _wrap_PiecewiseKrugerZero_nodes, METH_O, NULL},
	 { "delete_PiecewiseKrugerZero", _wrap_delete_PiecewiseKrugerZero, METH_O, NULL},
	 { "PiecewiseKrugerZero_swigregister", PiecewiseKrugerZero_swigregister, METH_O, NULL},
	 { "PiecewiseKrugerZero_swiginit", PiecewiseKrugerZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseKrugerLogDiscount", _wrap_new_PiecewiseKrugerLogDiscount, METH_VARARGS, NULL},
	 { "PiecewiseKrugerLogDiscount_dates", _wrap_PiecewiseKrugerLogDiscount_dates, METH_O, NULL},
	 { "PiecewiseKrugerLogDiscount_times", _wrap_PiecewiseKrugerLogDiscount_times, METH_O, NULL},
	 { "PiecewiseKrugerLogDiscount_nodes", _wrap_PiecewiseKrugerLogDiscount_nodes, METH_O, NULL},
	 { "delete_PiecewiseKrugerLogDiscount", _wrap_delete_PiecewiseKrugerLogDiscount, METH_O, NULL},
	 { "PiecewiseKrugerLogDiscount_swigregister", PiecewiseKrugerLogDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseKrugerLogDiscount_swiginit", PiecewiseKrugerLogDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseConvexMonotoneZero", _wrap_new_PiecewiseConvexMonotoneZero, METH_VARARGS, NULL},
	 { "PiecewiseConvexMonotoneZero_dates", _wrap_PiecewiseConvexMonotoneZero_dates, METH_O, NULL},
	 { "PiecewiseConvexMonotoneZero_times", _wrap_PiecewiseConvexMonotoneZero_times, METH_O, NULL},
	 { "PiecewiseConvexMonotoneZero_nodes", _wrap_PiecewiseConvexMonotoneZero_nodes, METH_O, NULL},
	 { "delete_PiecewiseConvexMonotoneZero", _wrap_delete_PiecewiseConvexMonotoneZero, METH_O, NULL},
	 { "PiecewiseConvexMonotoneZero_swigregister", PiecewiseConvexMonotoneZero_swigregister, METH_O, NULL},
	 { "PiecewiseConvexMonotoneZero_swiginit", PiecewiseConvexMonotoneZero_swiginit, METH_VARARGS, NULL},
	 { "new_GlobalBootstrap", _wrap_new_GlobalBootstrap, METH_VARARGS, NULL},
	 { "delete_GlobalBootstrap", _wrap_delete_GlobalBootstrap, METH_O, NULL},
	 { "GlobalBootstrap_swigregister", GlobalBootstrap_swigregister, METH_O, NULL},
	 { "GlobalBootstrap_swiginit", GlobalBootstrap_swiginit, METH_VARARGS, NULL},
	 { "new_GlobalLinearSimpleZeroCurve", _wrap_new_GlobalLinearSimpleZeroCurve, METH_VARARGS, NULL},
	 { "GlobalLinearSimpleZeroCurve_dates", _wrap_GlobalLinearSimpleZeroCurve_dates, METH_O, NULL},
	 { "GlobalLinearSimpleZeroCurve_times", _wrap_GlobalLinearSimpleZeroCurve_times, METH_O, NULL},
	 { "GlobalLinearSimpleZeroCurve_nodes", _wrap_GlobalLinearSimpleZeroCurve_nodes, METH_O, NULL},
	 { "delete_GlobalLinearSimpleZeroCurve", _wrap_delete_GlobalLinearSimpleZeroCurve, METH_O, NULL},
	 { "GlobalLinearSimpleZeroCurve_swigregister", GlobalLinearSimpleZeroCurve_swigregister, METH_O, NULL},
	 { "GlobalLinearSimpleZeroCurve_swiginit", GlobalLinearSimpleZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructure_defaultProbability", _wrap_DefaultProbabilityTermStructure_defaultProbability, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructure_survivalProbability", _wrap_DefaultProbabilityTermStructure_survivalProbability, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructure_defaultDensity", _wrap_DefaultProbabilityTermStructure_defaultDensity, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructure_hazardRate", _wrap_DefaultProbabilityTermStructure_hazardRate, METH_VARARGS, NULL},
	 { "delete_DefaultProbabilityTermStructure", _wrap_delete_DefaultProbabilityTermStructure, METH_O, NULL},
	 { "DefaultProbabilityTermStructure_swigregister", DefaultProbabilityTermStructure_swigregister, METH_O, NULL},
	 { "new_DefaultProbabilityTermStructureHandle", _wrap_new_DefaultProbabilityTermStructureHandle, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructureHandle___deref__", _wrap_DefaultProbabilityTermStructureHandle___deref__, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_currentLink", _wrap_DefaultProbabilityTermStructureHandle_currentLink, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle___nonzero__", _wrap_DefaultProbabilityTermStructureHandle___nonzero__, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle___bool__", _wrap_DefaultProbabilityTermStructureHandle___bool__, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_asObservable", _wrap_DefaultProbabilityTermStructureHandle_asObservable, METH_O, NULL},
	 { "delete_DefaultProbabilityTermStructureHandle", _wrap_delete_DefaultProbabilityTermStructureHandle, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_defaultProbability", _wrap_DefaultProbabilityTermStructureHandle_defaultProbability, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructureHandle_survivalProbability", _wrap_DefaultProbabilityTermStructureHandle_survivalProbability, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructureHandle_defaultDensity", _wrap_DefaultProbabilityTermStructureHandle_defaultDensity, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructureHandle_hazardRate", _wrap_DefaultProbabilityTermStructureHandle_hazardRate, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructureHandle_dayCounter", _wrap_DefaultProbabilityTermStructureHandle_dayCounter, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_timeFromReference", _wrap_DefaultProbabilityTermStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructureHandle_calendar", _wrap_DefaultProbabilityTermStructureHandle_calendar, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_referenceDate", _wrap_DefaultProbabilityTermStructureHandle_referenceDate, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_maxDate", _wrap_DefaultProbabilityTermStructureHandle_maxDate, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_maxTime", _wrap_DefaultProbabilityTermStructureHandle_maxTime, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_enableExtrapolation", _wrap_DefaultProbabilityTermStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_disableExtrapolation", _wrap_DefaultProbabilityTermStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_allowsExtrapolation", _wrap_DefaultProbabilityTermStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_swigregister", DefaultProbabilityTermStructureHandle_swigregister, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_swiginit", DefaultProbabilityTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableDefaultProbabilityTermStructureHandle", _wrap_new_RelinkableDefaultProbabilityTermStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableDefaultProbabilityTermStructureHandle_linkTo", _wrap_RelinkableDefaultProbabilityTermStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableDefaultProbabilityTermStructureHandle_reset", _wrap_RelinkableDefaultProbabilityTermStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableDefaultProbabilityTermStructureHandle", _wrap_delete_RelinkableDefaultProbabilityTermStructureHandle, METH_O, NULL},
	 { "RelinkableDefaultProbabilityTermStructureHandle_swigregister", RelinkableDefaultProbabilityTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableDefaultProbabilityTermStructureHandle_swiginit", RelinkableDefaultProbabilityTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_FlatHazardRate", _wrap_new_FlatHazardRate, METH_VARARGS, NULL},
	 { "delete_FlatHazardRate", _wrap_delete_FlatHazardRate, METH_O, NULL},
	 { "FlatHazardRate_swigregister", FlatHazardRate_swigregister, METH_O, NULL},
	 { "FlatHazardRate_swiginit", FlatHazardRate_swiginit, METH_VARARGS, NULL},
	 { "new_HazardRateCurve", _wrap_new_HazardRateCurve, METH_VARARGS, NULL},
	 { "HazardRateCurve_dates", _wrap_HazardRateCurve_dates, METH_O, NULL},
	 { "HazardRateCurve_hazardRates", _wrap_HazardRateCurve_hazardRates, METH_O, NULL},
	 { "HazardRateCurve_nodes", _wrap_HazardRateCurve_nodes, METH_O, NULL},
	 { "delete_HazardRateCurve", _wrap_delete_HazardRateCurve, METH_O, NULL},
	 { "HazardRateCurve_swigregister", HazardRateCurve_swigregister, METH_O, NULL},
	 { "HazardRateCurve_swiginit", HazardRateCurve_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultDensityCurve", _wrap_new_DefaultDensityCurve, METH_VARARGS, NULL},
	 { "DefaultDensityCurve_dates", _wrap_DefaultDensityCurve_dates, METH_O, NULL},
	 { "DefaultDensityCurve_defaultDensities", _wrap_DefaultDensityCurve_defaultDensities, METH_O, NULL},
	 { "DefaultDensityCurve_nodes", _wrap_DefaultDensityCurve_nodes, METH_O, NULL},
	 { "delete_DefaultDensityCurve", _wrap_delete_DefaultDensityCurve, METH_O, NULL},
	 { "DefaultDensityCurve_swigregister", DefaultDensityCurve_swigregister, METH_O, NULL},
	 { "DefaultDensityCurve_swiginit", DefaultDensityCurve_swiginit, METH_VARARGS, NULL},
	 { "new_SurvivalProbabilityCurve", _wrap_new_SurvivalProbabilityCurve, METH_VARARGS, NULL},
	 { "SurvivalProbabilityCurve_dates", _wrap_SurvivalProbabilityCurve_dates, METH_O, NULL},
	 { "SurvivalProbabilityCurve_survivalProbabilities", _wrap_SurvivalProbabilityCurve_survivalProbabilities, METH_O, NULL},
	 { "SurvivalProbabilityCurve_nodes", _wrap_SurvivalProbabilityCurve_nodes, METH_O, NULL},
	 { "delete_SurvivalProbabilityCurve", _wrap_delete_SurvivalProbabilityCurve, METH_O, NULL},
	 { "SurvivalProbabilityCurve_swigregister", SurvivalProbabilityCurve_swigregister, METH_O, NULL},
	 { "SurvivalProbabilityCurve_swiginit", SurvivalProbabilityCurve_swiginit, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelper_quote", _wrap_DefaultProbabilityHelper_quote, METH_O, NULL},
	 { "DefaultProbabilityHelper_latestDate", _wrap_DefaultProbabilityHelper_latestDate, METH_O, NULL},
	 { "DefaultProbabilityHelper_earliestDate", _wrap_DefaultProbabilityHelper_earliestDate, METH_O, NULL},
	 { "DefaultProbabilityHelper_maturityDate", _wrap_DefaultProbabilityHelper_maturityDate, METH_O, NULL},
	 { "DefaultProbabilityHelper_latestRelevantDate", _wrap_DefaultProbabilityHelper_latestRelevantDate, METH_O, NULL},
	 { "DefaultProbabilityHelper_pillarDate", _wrap_DefaultProbabilityHelper_pillarDate, METH_O, NULL},
	 { "DefaultProbabilityHelper_impliedQuote", _wrap_DefaultProbabilityHelper_impliedQuote, METH_O, NULL},
	 { "DefaultProbabilityHelper_quoteError", _wrap_DefaultProbabilityHelper_quoteError, METH_O, NULL},
	 { "delete_DefaultProbabilityHelper", _wrap_delete_DefaultProbabilityHelper, METH_O, NULL},
	 { "DefaultProbabilityHelper_swigregister", DefaultProbabilityHelper_swigregister, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_iterator", _wrap_DefaultProbabilityHelperVector_iterator, METH_O, NULL},
	 { "DefaultProbabilityHelperVector___nonzero__", _wrap_DefaultProbabilityHelperVector___nonzero__, METH_O, NULL},
	 { "DefaultProbabilityHelperVector___bool__", _wrap_DefaultProbabilityHelperVector___bool__, METH_O, NULL},
	 { "DefaultProbabilityHelperVector___len__", _wrap_DefaultProbabilityHelperVector___len__, METH_O, NULL},
	 { "DefaultProbabilityHelperVector___getslice__", _wrap_DefaultProbabilityHelperVector___getslice__, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector___setslice__", _wrap_DefaultProbabilityHelperVector___setslice__, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector___delslice__", _wrap_DefaultProbabilityHelperVector___delslice__, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector___delitem__", _wrap_DefaultProbabilityHelperVector___delitem__, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector___getitem__", _wrap_DefaultProbabilityHelperVector___getitem__, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector___setitem__", _wrap_DefaultProbabilityHelperVector___setitem__, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_pop", _wrap_DefaultProbabilityHelperVector_pop, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_append", _wrap_DefaultProbabilityHelperVector_append, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_empty", _wrap_DefaultProbabilityHelperVector_empty, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_size", _wrap_DefaultProbabilityHelperVector_size, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_swap", _wrap_DefaultProbabilityHelperVector_swap, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_begin", _wrap_DefaultProbabilityHelperVector_begin, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_end", _wrap_DefaultProbabilityHelperVector_end, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_rbegin", _wrap_DefaultProbabilityHelperVector_rbegin, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_rend", _wrap_DefaultProbabilityHelperVector_rend, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_clear", _wrap_DefaultProbabilityHelperVector_clear, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_get_allocator", _wrap_DefaultProbabilityHelperVector_get_allocator, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_pop_back", _wrap_DefaultProbabilityHelperVector_pop_back, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_erase", _wrap_DefaultProbabilityHelperVector_erase, METH_VARARGS, NULL},
	 { "new_DefaultProbabilityHelperVector", _wrap_new_DefaultProbabilityHelperVector, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_push_back", _wrap_DefaultProbabilityHelperVector_push_back, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_front", _wrap_DefaultProbabilityHelperVector_front, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_back", _wrap_DefaultProbabilityHelperVector_back, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_assign", _wrap_DefaultProbabilityHelperVector_assign, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_resize", _wrap_DefaultProbabilityHelperVector_resize, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_insert", _wrap_DefaultProbabilityHelperVector_insert, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_reserve", _wrap_DefaultProbabilityHelperVector_reserve, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelperVector_capacity", _wrap_DefaultProbabilityHelperVector_capacity, METH_O, NULL},
	 { "delete_DefaultProbabilityHelperVector", _wrap_delete_DefaultProbabilityHelperVector, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_swigregister", DefaultProbabilityHelperVector_swigregister, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_swiginit", DefaultProbabilityHelperVector_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadCdsHelper", _wrap_new_SpreadCdsHelper, METH_VARARGS, NULL},
	 { "delete_SpreadCdsHelper", _wrap_delete_SpreadCdsHelper, METH_O, NULL},
	 { "SpreadCdsHelper_swigregister", SpreadCdsHelper_swigregister, METH_O, NULL},
	 { "SpreadCdsHelper_swiginit", SpreadCdsHelper_swiginit, METH_VARARGS, NULL},
	 { "new_UpfrontCdsHelper", _wrap_new_UpfrontCdsHelper, METH_VARARGS, NULL},
	 { "delete_UpfrontCdsHelper", _wrap_delete_UpfrontCdsHelper, METH_O, NULL},
	 { "UpfrontCdsHelper_swigregister", UpfrontCdsHelper_swigregister, METH_O, NULL},
	 { "UpfrontCdsHelper_swiginit", UpfrontCdsHelper_swiginit, METH_VARARGS, NULL},
	 { "new_HazardRate", _wrap_new_HazardRate, METH_NOARGS, NULL},
	 { "delete_HazardRate", _wrap_delete_HazardRate, METH_O, NULL},
	 { "HazardRate_swigregister", HazardRate_swigregister, METH_O, NULL},
	 { "HazardRate_swiginit", HazardRate_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultDensity", _wrap_new_DefaultDensity, METH_NOARGS, NULL},
	 { "delete_DefaultDensity", _wrap_delete_DefaultDensity, METH_O, NULL},
	 { "DefaultDensity_swigregister", DefaultDensity_swigregister, METH_O, NULL},
	 { "DefaultDensity_swiginit", DefaultDensity_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseFlatHazardRate", _wrap_new_PiecewiseFlatHazardRate, METH_VARARGS, NULL},
	 { "PiecewiseFlatHazardRate_dates", _wrap_PiecewiseFlatHazardRate_dates, METH_O, NULL},
	 { "PiecewiseFlatHazardRate_times", _wrap_PiecewiseFlatHazardRate_times, METH_O, NULL},
	 { "PiecewiseFlatHazardRate_nodes", _wrap_PiecewiseFlatHazardRate_nodes, METH_O, NULL},
	 { "delete_PiecewiseFlatHazardRate", _wrap_delete_PiecewiseFlatHazardRate, METH_O, NULL},
	 { "PiecewiseFlatHazardRate_swigregister", PiecewiseFlatHazardRate_swigregister, METH_O, NULL},
	 { "PiecewiseFlatHazardRate_swiginit", PiecewiseFlatHazardRate_swiginit, METH_VARARGS, NULL},
	 { "new_Protection", _wrap_new_Protection, METH_NOARGS, NULL},
	 { "delete_Protection", _wrap_delete_Protection, METH_O, NULL},
	 { "Protection_swigregister", Protection_swigregister, METH_O, NULL},
	 { "Protection_swiginit", Protection_swiginit, METH_VARARGS, NULL},
	 { "Claim_amount", _wrap_Claim_amount, METH_VARARGS, NULL},
	 { "delete_Claim", _wrap_delete_Claim, METH_O, NULL},
	 { "Claim_swigregister", Claim_swigregister, METH_O, NULL},
	 { "new_FaceValueClaim", _wrap_new_FaceValueClaim, METH_NOARGS, NULL},
	 { "delete_FaceValueClaim", _wrap_delete_FaceValueClaim, METH_O, NULL},
	 { "FaceValueClaim_swigregister", FaceValueClaim_swigregister, METH_O, NULL},
	 { "FaceValueClaim_swiginit", FaceValueClaim_swiginit, METH_VARARGS, NULL},
	 { "new_FaceValueAccrualClaim", _wrap_new_FaceValueAccrualClaim, METH_O, NULL},
	 { "delete_FaceValueAccrualClaim", _wrap_delete_FaceValueAccrualClaim, METH_O, NULL},
	 { "FaceValueAccrualClaim_swigregister", FaceValueAccrualClaim_swigregister, METH_O, NULL},
	 { "FaceValueAccrualClaim_swiginit", FaceValueAccrualClaim_swiginit, METH_VARARGS, NULL},
	 { "new_CreditDefaultSwap", _wrap_new_CreditDefaultSwap, METH_VARARGS, NULL},
	 { "CreditDefaultSwap_side", _wrap_CreditDefaultSwap_side, METH_O, NULL},
	 { "CreditDefaultSwap_notional", _wrap_CreditDefaultSwap_notional, METH_O, NULL},
	 { "CreditDefaultSwap_runningSpread", _wrap_CreditDefaultSwap_runningSpread, METH_O, NULL},
	 { "CreditDefaultSwap_upfront", _wrap_CreditDefaultSwap_upfront, METH_O, NULL},
	 { "CreditDefaultSwap_settlesAccrual", _wrap_CreditDefaultSwap_settlesAccrual, METH_O, NULL},
	 { "CreditDefaultSwap_paysAtDefaultTime", _wrap_CreditDefaultSwap_paysAtDefaultTime, METH_O, NULL},
	 { "CreditDefaultSwap_fairSpread", _wrap_CreditDefaultSwap_fairSpread, METH_O, NULL},
	 { "CreditDefaultSwap_fairUpfront", _wrap_CreditDefaultSwap_fairUpfront, METH_O, NULL},
	 { "CreditDefaultSwap_couponLegBPS", _wrap_CreditDefaultSwap_couponLegBPS, METH_O, NULL},
	 { "CreditDefaultSwap_couponLegNPV", _wrap_CreditDefaultSwap_couponLegNPV, METH_O, NULL},
	 { "CreditDefaultSwap_defaultLegNPV", _wrap_CreditDefaultSwap_defaultLegNPV, METH_O, NULL},
	 { "CreditDefaultSwap_upfrontBPS", _wrap_CreditDefaultSwap_upfrontBPS, METH_O, NULL},
	 { "CreditDefaultSwap_upfrontNPV", _wrap_CreditDefaultSwap_upfrontNPV, METH_O, NULL},
	 { "CreditDefaultSwap_impliedHazardRate", _wrap_CreditDefaultSwap_impliedHazardRate, METH_VARARGS, NULL},
	 { "CreditDefaultSwap_conventionalSpread", _wrap_CreditDefaultSwap_conventionalSpread, METH_VARARGS, NULL},
	 { "CreditDefaultSwap_coupons", _wrap_CreditDefaultSwap_coupons, METH_O, NULL},
	 { "delete_CreditDefaultSwap", _wrap_delete_CreditDefaultSwap, METH_O, NULL},
	 { "CreditDefaultSwap_swigregister", CreditDefaultSwap_swigregister, METH_O, NULL},
	 { "CreditDefaultSwap_swiginit", CreditDefaultSwap_swiginit, METH_VARARGS, NULL},
	 { "new_MidPointCdsEngine", _wrap_new_MidPointCdsEngine, METH_VARARGS, NULL},
	 { "delete_MidPointCdsEngine", _wrap_delete_MidPointCdsEngine, METH_O, NULL},
	 { "MidPointCdsEngine_swigregister", MidPointCdsEngine_swigregister, METH_O, NULL},
	 { "MidPointCdsEngine_swiginit", MidPointCdsEngine_swiginit, METH_VARARGS, NULL},
	 { "new_IntegralCdsEngine", _wrap_new_IntegralCdsEngine, METH_VARARGS, NULL},
	 { "delete_IntegralCdsEngine", _wrap_delete_IntegralCdsEngine, METH_O, NULL},
	 { "IntegralCdsEngine_swigregister", IntegralCdsEngine_swigregister, METH_O, NULL},
	 { "IntegralCdsEngine_swiginit", IntegralCdsEngine_swiginit, METH_VARARGS, NULL},
	 { "new_IsdaCdsEngine", _wrap_new_IsdaCdsEngine, METH_VARARGS, NULL},
	 { "delete_IsdaCdsEngine", _wrap_delete_IsdaCdsEngine, METH_O, NULL},
	 { "IsdaCdsEngine_swigregister", IsdaCdsEngine_swigregister, METH_O, NULL},
	 { "IsdaCdsEngine_swiginit", IsdaCdsEngine_swiginit, METH_VARARGS, NULL},
	 { "new_CdsOption", _wrap_new_CdsOption, METH_VARARGS, NULL},
	 { "CdsOption_atmRate", _wrap_CdsOption_atmRate, METH_O, NULL},
	 { "CdsOption_riskyAnnuity", _wrap_CdsOption_riskyAnnuity, METH_O, NULL},
	 { "CdsOption_impliedVolatility", _wrap_CdsOption_impliedVolatility, METH_VARARGS, NULL},
	 { "delete_CdsOption", _wrap_delete_CdsOption, METH_O, NULL},
	 { "CdsOption_swigregister", CdsOption_swigregister, METH_O, NULL},
	 { "CdsOption_swiginit", CdsOption_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCdsOptionEngine", _wrap_new_BlackCdsOptionEngine, METH_VARARGS, NULL},
	 { "BlackCdsOptionEngine_termStructure", _wrap_BlackCdsOptionEngine_termStructure, METH_O, NULL},
	 { "BlackCdsOptionEngine_volatility", _wrap_BlackCdsOptionEngine_volatility, METH_O, NULL},
	 { "delete_BlackCdsOptionEngine", _wrap_delete_BlackCdsOptionEngine, METH_O, NULL},
	 { "BlackCdsOptionEngine_swigregister", BlackCdsOptionEngine_swigregister, METH_O, NULL},
	 { "BlackCdsOptionEngine_swiginit", BlackCdsOptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DiscountCurve", _wrap_new_DiscountCurve, METH_VARARGS, NULL},
	 { "DiscountCurve_times", _wrap_DiscountCurve_times, METH_O, NULL},
	 { "DiscountCurve_data", _wrap_DiscountCurve_data, METH_O, NULL},
	 { "DiscountCurve_dates", _wrap_DiscountCurve_dates, METH_O, NULL},
	 { "DiscountCurve_discounts", _wrap_DiscountCurve_discounts, METH_O, NULL},
	 { "DiscountCurve_nodes", _wrap_DiscountCurve_nodes, METH_O, NULL},
	 { "delete_DiscountCurve", _wrap_delete_DiscountCurve, METH_O, NULL},
	 { "DiscountCurve_swigregister", DiscountCurve_swigregister, METH_O, NULL},
	 { "DiscountCurve_swiginit", DiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogCubicDiscountCurve", _wrap_new_MonotonicLogCubicDiscountCurve, METH_VARARGS, NULL},
	 { "MonotonicLogCubicDiscountCurve_times", _wrap_MonotonicLogCubicDiscountCurve_times, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_data", _wrap_MonotonicLogCubicDiscountCurve_data, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_dates", _wrap_MonotonicLogCubicDiscountCurve_dates, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_discounts", _wrap_MonotonicLogCubicDiscountCurve_discounts, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_nodes", _wrap_MonotonicLogCubicDiscountCurve_nodes, METH_O, NULL},
	 { "delete_MonotonicLogCubicDiscountCurve", _wrap_delete_MonotonicLogCubicDiscountCurve, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_swigregister", MonotonicLogCubicDiscountCurve_swigregister, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_swiginit", MonotonicLogCubicDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NaturalCubicDiscountCurve", _wrap_new_NaturalCubicDiscountCurve, METH_VARARGS, NULL},
	 { "NaturalCubicDiscountCurve_times", _wrap_NaturalCubicDiscountCurve_times, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_data", _wrap_NaturalCubicDiscountCurve_data, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_dates", _wrap_NaturalCubicDiscountCurve_dates, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_discounts", _wrap_NaturalCubicDiscountCurve_discounts, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_nodes", _wrap_NaturalCubicDiscountCurve_nodes, METH_O, NULL},
	 { "delete_NaturalCubicDiscountCurve", _wrap_delete_NaturalCubicDiscountCurve, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_swigregister", NaturalCubicDiscountCurve_swigregister, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_swiginit", NaturalCubicDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NormalDistribution", _wrap_new_NormalDistribution, METH_VARARGS, NULL},
	 { "NormalDistribution___call__", _wrap_NormalDistribution___call__, METH_VARARGS, NULL},
	 { "NormalDistribution_derivative", _wrap_NormalDistribution_derivative, METH_VARARGS, NULL},
	 { "delete_NormalDistribution", _wrap_delete_NormalDistribution, METH_O, NULL},
	 { "NormalDistribution_swigregister", NormalDistribution_swigregister, METH_O, NULL},
	 { "NormalDistribution_swiginit", NormalDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeNormalDistribution", _wrap_new_CumulativeNormalDistribution, METH_VARARGS, NULL},
	 { "CumulativeNormalDistribution___call__", _wrap_CumulativeNormalDistribution___call__, METH_VARARGS, NULL},
	 { "CumulativeNormalDistribution_derivative", _wrap_CumulativeNormalDistribution_derivative, METH_VARARGS, NULL},
	 { "delete_CumulativeNormalDistribution", _wrap_delete_CumulativeNormalDistribution, METH_O, NULL},
	 { "CumulativeNormalDistribution_swigregister", CumulativeNormalDistribution_swigregister, METH_O, NULL},
	 { "CumulativeNormalDistribution_swiginit", CumulativeNormalDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseCumulativeNormal", _wrap_new_InverseCumulativeNormal, METH_VARARGS, NULL},
	 { "InverseCumulativeNormal___call__", _wrap_InverseCumulativeNormal___call__, METH_VARARGS, NULL},
	 { "delete_InverseCumulativeNormal", _wrap_delete_InverseCumulativeNormal, METH_O, NULL},
	 { "InverseCumulativeNormal_swigregister", InverseCumulativeNormal_swigregister, METH_O, NULL},
	 { "InverseCumulativeNormal_swiginit", InverseCumulativeNormal_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInverseCumulativeNormal", _wrap_new_MoroInverseCumulativeNormal, METH_VARARGS, NULL},
	 { "MoroInverseCumulativeNormal___call__", _wrap_MoroInverseCumulativeNormal___call__, METH_VARARGS, NULL},
	 { "delete_MoroInverseCumulativeNormal", _wrap_delete_MoroInverseCumulativeNormal, METH_O, NULL},
	 { "MoroInverseCumulativeNormal_swigregister", MoroInverseCumulativeNormal_swigregister, METH_O, NULL},
	 { "MoroInverseCumulativeNormal_swiginit", MoroInverseCumulativeNormal_swiginit, METH_VARARGS, NULL},
	 { "new_BivariateCumulativeNormalDistribution", _wrap_new_BivariateCumulativeNormalDistribution, METH_O, NULL},
	 { "BivariateCumulativeNormalDistribution___call__", _wrap_BivariateCumulativeNormalDistribution___call__, METH_VARARGS, NULL},
	 { "delete_BivariateCumulativeNormalDistribution", _wrap_delete_BivariateCumulativeNormalDistribution, METH_O, NULL},
	 { "BivariateCumulativeNormalDistribution_swigregister", BivariateCumulativeNormalDistribution_swigregister, METH_O, NULL},
	 { "BivariateCumulativeNormalDistribution_swiginit", BivariateCumulativeNormalDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialDistribution", _wrap_new_BinomialDistribution, METH_VARARGS, NULL},
	 { "BinomialDistribution___call__", _wrap_BinomialDistribution___call__, METH_VARARGS, NULL},
	 { "delete_BinomialDistribution", _wrap_delete_BinomialDistribution, METH_O, NULL},
	 { "BinomialDistribution_swigregister", BinomialDistribution_swigregister, METH_O, NULL},
	 { "BinomialDistribution_swiginit", BinomialDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeBinomialDistribution", _wrap_new_CumulativeBinomialDistribution, METH_VARARGS, NULL},
	 { "CumulativeBinomialDistribution___call__", _wrap_CumulativeBinomialDistribution___call__, METH_VARARGS, NULL},
	 { "delete_CumulativeBinomialDistribution", _wrap_delete_CumulativeBinomialDistribution, METH_O, NULL},
	 { "CumulativeBinomialDistribution_swigregister", CumulativeBinomialDistribution_swigregister, METH_O, NULL},
	 { "CumulativeBinomialDistribution_swiginit", CumulativeBinomialDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_BivariateCumulativeNormalDistributionDr78", _wrap_new_BivariateCumulativeNormalDistributionDr78, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionDr78___call__", _wrap_BivariateCumulativeNormalDistributionDr78___call__, METH_VARARGS, NULL},
	 { "delete_BivariateCumulativeNormalDistributionDr78", _wrap_delete_BivariateCumulativeNormalDistributionDr78, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionDr78_swigregister", BivariateCumulativeNormalDistributionDr78_swigregister, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionDr78_swiginit", BivariateCumulativeNormalDistributionDr78_swiginit, METH_VARARGS, NULL},
	 { "new_BivariateCumulativeNormalDistributionWe04DP", _wrap_new_BivariateCumulativeNormalDistributionWe04DP, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionWe04DP___call__", _wrap_BivariateCumulativeNormalDistributionWe04DP___call__, METH_VARARGS, NULL},
	 { "delete_BivariateCumulativeNormalDistributionWe04DP", _wrap_delete_BivariateCumulativeNormalDistributionWe04DP, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionWe04DP_swigregister", BivariateCumulativeNormalDistributionWe04DP_swigregister, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionWe04DP_swiginit", BivariateCumulativeNormalDistributionWe04DP_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeChiSquareDistribution", _wrap_new_CumulativeChiSquareDistribution, METH_O, NULL},
	 { "CumulativeChiSquareDistribution___call__", _wrap_CumulativeChiSquareDistribution___call__, METH_VARARGS, NULL},
	 { "delete_CumulativeChiSquareDistribution", _wrap_delete_CumulativeChiSquareDistribution, METH_O, NULL},
	 { "CumulativeChiSquareDistribution_swigregister", CumulativeChiSquareDistribution_swigregister, METH_O, NULL},
	 { "CumulativeChiSquareDistribution_swiginit", CumulativeChiSquareDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_NonCentralCumulativeChiSquareDistribution", _wrap_new_NonCentralCumulativeChiSquareDistribution, METH_VARARGS, NULL},
	 { "NonCentralCumulativeChiSquareDistribution___call__", _wrap_NonCentralCumulativeChiSquareDistribution___call__, METH_VARARGS, NULL},
	 { "delete_NonCentralCumulativeChiSquareDistribution", _wrap_delete_NonCentralCumulativeChiSquareDistribution, METH_O, NULL},
	 { "NonCentralCumulativeChiSquareDistribution_swigregister", NonCentralCumulativeChiSquareDistribution_swigregister, METH_O, NULL},
	 { "NonCentralCumulativeChiSquareDistribution_swiginit", NonCentralCumulativeChiSquareDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseNonCentralCumulativeChiSquareDistribution", _wrap_new_InverseNonCentralCumulativeChiSquareDistribution, METH_VARARGS, NULL},
	 { "InverseNonCentralCumulativeChiSquareDistribution___call__", _wrap_InverseNonCentralCumulativeChiSquareDistribution___call__, METH_VARARGS, NULL},
	 { "delete_InverseNonCentralCumulativeChiSquareDistribution", _wrap_delete_InverseNonCentralCumulativeChiSquareDistribution, METH_O, NULL},
	 { "InverseNonCentralCumulativeChiSquareDistribution_swigregister", InverseNonCentralCumulativeChiSquareDistribution_swigregister, METH_O, NULL},
	 { "InverseNonCentralCumulativeChiSquareDistribution_swiginit", InverseNonCentralCumulativeChiSquareDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeGammaDistribution", _wrap_new_CumulativeGammaDistribution, METH_O, NULL},
	 { "CumulativeGammaDistribution___call__", _wrap_CumulativeGammaDistribution___call__, METH_VARARGS, NULL},
	 { "delete_CumulativeGammaDistribution", _wrap_delete_CumulativeGammaDistribution, METH_O, NULL},
	 { "CumulativeGammaDistribution_swigregister", CumulativeGammaDistribution_swigregister, METH_O, NULL},
	 { "CumulativeGammaDistribution_swiginit", CumulativeGammaDistribution_swiginit, METH_VARARGS, NULL},
	 { "GammaFunction_logValue", _wrap_GammaFunction_logValue, METH_VARARGS, NULL},
	 { "new_GammaFunction", _wrap_new_GammaFunction, METH_NOARGS, NULL},
	 { "delete_GammaFunction", _wrap_delete_GammaFunction, METH_O, NULL},
	 { "GammaFunction_swigregister", GammaFunction_swigregister, METH_O, NULL},
	 { "GammaFunction_swiginit", GammaFunction_swiginit, METH_VARARGS, NULL},
	 { "new_PoissonDistribution", _wrap_new_PoissonDistribution, METH_O, NULL},
	 { "PoissonDistribution___call__", _wrap_PoissonDistribution___call__, METH_VARARGS, NULL},
	 { "delete_PoissonDistribution", _wrap_delete_PoissonDistribution, METH_O, NULL},
	 { "PoissonDistribution_swigregister", PoissonDistribution_swigregister, METH_O, NULL},
	 { "PoissonDistribution_swiginit", PoissonDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativePoissonDistribution", _wrap_new_CumulativePoissonDistribution, METH_O, NULL},
	 { "CumulativePoissonDistribution___call__", _wrap_CumulativePoissonDistribution___call__, METH_VARARGS, NULL},
	 { "delete_CumulativePoissonDistribution", _wrap_delete_CumulativePoissonDistribution, METH_O, NULL},
	 { "CumulativePoissonDistribution_swigregister", CumulativePoissonDistribution_swigregister, METH_O, NULL},
	 { "CumulativePoissonDistribution_swiginit", CumulativePoissonDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseCumulativePoisson", _wrap_new_InverseCumulativePoisson, METH_O, NULL},
	 { "InverseCumulativePoisson___call__", _wrap_InverseCumulativePoisson___call__, METH_VARARGS, NULL},
	 { "delete_InverseCumulativePoisson", _wrap_delete_InverseCumulativePoisson, METH_O, NULL},
	 { "InverseCumulativePoisson_swigregister", InverseCumulativePoisson_swigregister, METH_O, NULL},
	 { "InverseCumulativePoisson_swiginit", InverseCumulativePoisson_swiginit, METH_VARARGS, NULL},
	 { "new_StudentDistribution", _wrap_new_StudentDistribution, METH_O, NULL},
	 { "StudentDistribution___call__", _wrap_StudentDistribution___call__, METH_VARARGS, NULL},
	 { "delete_StudentDistribution", _wrap_delete_StudentDistribution, METH_O, NULL},
	 { "StudentDistribution_swigregister", StudentDistribution_swigregister, METH_O, NULL},
	 { "StudentDistribution_swiginit", StudentDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeStudentDistribution", _wrap_new_CumulativeStudentDistribution, METH_O, NULL},
	 { "CumulativeStudentDistribution___call__", _wrap_CumulativeStudentDistribution___call__, METH_VARARGS, NULL},
	 { "delete_CumulativeStudentDistribution", _wrap_delete_CumulativeStudentDistribution, METH_O, NULL},
	 { "CumulativeStudentDistribution_swigregister", CumulativeStudentDistribution_swigregister, METH_O, NULL},
	 { "CumulativeStudentDistribution_swiginit", CumulativeStudentDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseCumulativeStudent", _wrap_new_InverseCumulativeStudent, METH_VARARGS, NULL},
	 { "InverseCumulativeStudent___call__", _wrap_InverseCumulativeStudent___call__, METH_VARARGS, NULL},
	 { "delete_InverseCumulativeStudent", _wrap_delete_InverseCumulativeStudent, METH_O, NULL},
	 { "InverseCumulativeStudent_swigregister", InverseCumulativeStudent_swigregister, METH_O, NULL},
	 { "InverseCumulativeStudent_swiginit", InverseCumulativeStudent_swiginit, METH_VARARGS, NULL},
	 { "new_Money", _wrap_new_Money, METH_VARARGS, NULL},
	 { "Money_currency", _wrap_Money_currency, METH_O, NULL},
	 { "Money_value", _wrap_Money_value, METH_O, NULL},
	 { "Money_rounded", _wrap_Money_rounded, METH_O, NULL},
	 { "Money___pos__", _wrap_Money___pos__, METH_O, NULL},
	 { "Money___neg__", _wrap_Money___neg__, METH_O, NULL},
	 { "Money___add__", _wrap_Money___add__, METH_VARARGS, NULL},
	 { "Money___sub__", _wrap_Money___sub__, METH_VARARGS, NULL},
	 { "Money___mul__", _wrap_Money___mul__, METH_VARARGS, NULL},
	 { "Money___truediv__", _wrap_Money___truediv__, METH_VARARGS, NULL},
	 { "Money___rmul__", _wrap_Money___rmul__, METH_VARARGS, NULL},
	 { "Money___lt__", _wrap_Money___lt__, METH_VARARGS, NULL},
	 { "Money___gt__", _wrap_Money___gt__, METH_VARARGS, NULL},
	 { "Money___le__", _wrap_Money___le__, METH_VARARGS, NULL},
	 { "Money___ge__", _wrap_Money___ge__, METH_VARARGS, NULL},
	 { "Money___cmp__", _wrap_Money___cmp__, METH_VARARGS, NULL},
	 { "Money___str__", _wrap_Money___str__, METH_O, NULL},
	 { "Money_setConversionType", _wrap_Money_setConversionType, METH_O, NULL},
	 { "Money_setBaseCurrency", _wrap_Money_setBaseCurrency, METH_O, NULL},
	 { "delete_Money", _wrap_delete_Money, METH_O, NULL},
	 { "Money_swigregister", Money_swigregister, METH_O, NULL},
	 { "Money_swiginit", Money_swiginit, METH_VARARGS, NULL},
	 { "new_ExchangeRate", _wrap_new_ExchangeRate, METH_VARARGS, NULL},
	 { "ExchangeRate_source", _wrap_ExchangeRate_source, METH_O, NULL},
	 { "ExchangeRate_target", _wrap_ExchangeRate_target, METH_O, NULL},
	 { "ExchangeRate_type", _wrap_ExchangeRate_type, METH_O, NULL},
	 { "ExchangeRate_rate", _wrap_ExchangeRate_rate, METH_O, NULL},
	 { "ExchangeRate_exchange", _wrap_ExchangeRate_exchange, METH_VARARGS, NULL},
	 { "ExchangeRate_chain", _wrap_ExchangeRate_chain, METH_VARARGS, NULL},
	 { "delete_ExchangeRate", _wrap_delete_ExchangeRate, METH_O, NULL},
	 { "ExchangeRate_swigregister", ExchangeRate_swigregister, METH_O, NULL},
	 { "ExchangeRate_swiginit", ExchangeRate_swiginit, METH_VARARGS, NULL},
	 { "ExchangeRateManager_instance", _wrap_ExchangeRateManager_instance, METH_NOARGS, NULL},
	 { "ExchangeRateManager_add", _wrap_ExchangeRateManager_add, METH_VARARGS, NULL},
	 { "ExchangeRateManager_lookup", _wrap_ExchangeRateManager_lookup, METH_VARARGS, NULL},
	 { "ExchangeRateManager_clear", _wrap_ExchangeRateManager_clear, METH_O, NULL},
	 { "delete_ExchangeRateManager", _wrap_delete_ExchangeRateManager, METH_O, NULL},
	 { "ExchangeRateManager_swigregister", ExchangeRateManager_swigregister, METH_O, NULL},
	 { "Settings_instance", _wrap_Settings_instance, METH_NOARGS, NULL},
	 { "Settings_getEvaluationDate", _wrap_Settings_getEvaluationDate, METH_O, NULL},
	 { "Settings_setEvaluationDate", _wrap_Settings_setEvaluationDate, METH_VARARGS, NULL},
	 { "Settings_includeReferenceDateEvents", _wrap_Settings_includeReferenceDateEvents, METH_VARARGS, NULL},
	 { "Settings_includeTodaysCashFlows", _wrap_Settings_includeTodaysCashFlows, METH_VARARGS, NULL},
	 { "Settings_setEnforcesTodaysHistoricFixings", _wrap_Settings_setEnforcesTodaysHistoricFixings, METH_VARARGS, NULL},
	 { "Settings_getEnforcesTodaysHistoricFixings", _wrap_Settings_getEnforcesTodaysHistoricFixings, METH_O, NULL},
	 { "delete_Settings", _wrap_delete_Settings, METH_O, NULL},
	 { "Settings_swigregister", Settings_swigregister, METH_O, NULL},
	 { "new_Fdm1dMesher", _wrap_new_Fdm1dMesher, METH_O, NULL},
	 { "Fdm1dMesher_size", _wrap_Fdm1dMesher_size, METH_O, NULL},
	 { "Fdm1dMesher_dplus", _wrap_Fdm1dMesher_dplus, METH_VARARGS, NULL},
	 { "Fdm1dMesher_dminus", _wrap_Fdm1dMesher_dminus, METH_VARARGS, NULL},
	 { "Fdm1dMesher_location", _wrap_Fdm1dMesher_location, METH_VARARGS, NULL},
	 { "Fdm1dMesher_locations", _wrap_Fdm1dMesher_locations, METH_O, NULL},
	 { "delete_Fdm1dMesher", _wrap_delete_Fdm1dMesher, METH_O, NULL},
	 { "Fdm1dMesher_swigregister", Fdm1dMesher_swigregister, METH_O, NULL},
	 { "Fdm1dMesher_swiginit", Fdm1dMesher_swiginit, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_iterator", _wrap_Fdm1dMesherVector_iterator, METH_O, NULL},
	 { "Fdm1dMesherVector___nonzero__", _wrap_Fdm1dMesherVector___nonzero__, METH_O, NULL},
	 { "Fdm1dMesherVector___bool__", _wrap_Fdm1dMesherVector___bool__, METH_O, NULL},
	 { "Fdm1dMesherVector___len__", _wrap_Fdm1dMesherVector___len__, METH_O, NULL},
	 { "Fdm1dMesherVector___getslice__", _wrap_Fdm1dMesherVector___getslice__, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector___setslice__", _wrap_Fdm1dMesherVector___setslice__, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector___delslice__", _wrap_Fdm1dMesherVector___delslice__, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector___delitem__", _wrap_Fdm1dMesherVector___delitem__, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector___getitem__", _wrap_Fdm1dMesherVector___getitem__, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector___setitem__", _wrap_Fdm1dMesherVector___setitem__, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_pop", _wrap_Fdm1dMesherVector_pop, METH_O, NULL},
	 { "Fdm1dMesherVector_append", _wrap_Fdm1dMesherVector_append, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_empty", _wrap_Fdm1dMesherVector_empty, METH_O, NULL},
	 { "Fdm1dMesherVector_size", _wrap_Fdm1dMesherVector_size, METH_O, NULL},
	 { "Fdm1dMesherVector_swap", _wrap_Fdm1dMesherVector_swap, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_begin", _wrap_Fdm1dMesherVector_begin, METH_O, NULL},
	 { "Fdm1dMesherVector_end", _wrap_Fdm1dMesherVector_end, METH_O, NULL},
	 { "Fdm1dMesherVector_rbegin", _wrap_Fdm1dMesherVector_rbegin, METH_O, NULL},
	 { "Fdm1dMesherVector_rend", _wrap_Fdm1dMesherVector_rend, METH_O, NULL},
	 { "Fdm1dMesherVector_clear", _wrap_Fdm1dMesherVector_clear, METH_O, NULL},
	 { "Fdm1dMesherVector_get_allocator", _wrap_Fdm1dMesherVector_get_allocator, METH_O, NULL},
	 { "Fdm1dMesherVector_pop_back", _wrap_Fdm1dMesherVector_pop_back, METH_O, NULL},
	 { "Fdm1dMesherVector_erase", _wrap_Fdm1dMesherVector_erase, METH_VARARGS, NULL},
	 { "new_Fdm1dMesherVector", _wrap_new_Fdm1dMesherVector, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_push_back", _wrap_Fdm1dMesherVector_push_back, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_front", _wrap_Fdm1dMesherVector_front, METH_O, NULL},
	 { "Fdm1dMesherVector_back", _wrap_Fdm1dMesherVector_back, METH_O, NULL},
	 { "Fdm1dMesherVector_assign", _wrap_Fdm1dMesherVector_assign, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_resize", _wrap_Fdm1dMesherVector_resize, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_insert", _wrap_Fdm1dMesherVector_insert, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_reserve", _wrap_Fdm1dMesherVector_reserve, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_capacity", _wrap_Fdm1dMesherVector_capacity, METH_O, NULL},
	 { "delete_Fdm1dMesherVector", _wrap_delete_Fdm1dMesherVector, METH_O, NULL},
	 { "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, NULL},
	 { "FdmBlackScholesMesher_processHelper", _wrap_FdmBlackScholesMesher_processHelper, METH_VARARGS, NULL},
	 { "delete_FdmBlackScholesMesher", _wrap_delete_FdmBlackScholesMesher, METH_O, NULL},
	 { "FdmBlackScholesMesher_swigregister", FdmBlackScholesMesher_swigregister, METH_O, NULL},
	 { "FdmBlackScholesMesher_swiginit", FdmBlackScholesMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Concentrating1dMesherPoint", _wrap_new_Concentrating1dMesherPoint, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPoint_first", _wrap_Concentrating1dMesherPoint_first, METH_O, NULL},
	 { "Concentrating1dMesherPoint_second", _wrap_Concentrating1dMesherPoint_second, METH_O, NULL},
	 { "Concentrating1dMesherPoint_third", _wrap_Concentrating1dMesherPoint_third, METH_O, NULL},
	 { "delete_Concentrating1dMesherPoint", _wrap_delete_Concentrating1dMesherPoint, METH_O, NULL},
	 { "Concentrating1dMesherPoint_swigregister", Concentrating1dMesherPoint_swigregister, METH_O, NULL},
	 { "Concentrating1dMesherPoint_swiginit", Concentrating1dMesherPoint_swiginit, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_iterator", _wrap_Concentrating1dMesherPointVector_iterator, METH_O, NULL},
	 { "Concentrating1dMesherPointVector___nonzero__", _wrap_Concentrating1dMesherPointVector___nonzero__, METH_O, NULL},
	 { "Concentrating1dMesherPointVector___bool__", _wrap_Concentrating1dMesherPointVector___bool__, METH_O, NULL},
	 { "Concentrating1dMesherPointVector___len__", _wrap_Concentrating1dMesherPointVector___len__, METH_O, NULL},
	 { "Concentrating1dMesherPointVector___getslice__", _wrap_Concentrating1dMesherPointVector___getslice__, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector___setslice__", _wrap_Concentrating1dMesherPointVector___setslice__, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector___delslice__", _wrap_Concentrating1dMesherPointVector___delslice__, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector___delitem__", _wrap_Concentrating1dMesherPointVector___delitem__, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector___getitem__", _wrap_Concentrating1dMesherPointVector___getitem__, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector___setitem__", _wrap_Concentrating1dMesherPointVector___setitem__, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_pop", _wrap_Concentrating1dMesherPointVector_pop, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_append", _wrap_Concentrating1dMesherPointVector_append, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_empty", _wrap_Concentrating1dMesherPointVector_empty, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_size", _wrap_Concentrating1dMesherPointVector_size, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_swap", _wrap_Concentrating1dMesherPointVector_swap, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_begin", _wrap_Concentrating1dMesherPointVector_begin, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_end", _wrap_Concentrating1dMesherPointVector_end, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_rbegin", _wrap_Concentrating1dMesherPointVector_rbegin, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_rend", _wrap_Concentrating1dMesherPointVector_rend, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_clear", _wrap_Concentrating1dMesherPointVector_clear, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_get_allocator", _wrap_Concentrating1dMesherPointVector_get_allocator, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_pop_back", _wrap_Concentrating1dMesherPointVector_pop_back, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_erase", _wrap_Concentrating1dMesherPointVector_erase, METH_VARARGS, NULL},
	 { "new_Concentrating1dMesherPointVector", _wrap_new_Concentrating1dMesherPointVector, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_push_back", _wrap_Concentrating1dMesherPointVector_push_back, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_front", _wrap_Concentrating1dMesherPointVector_front, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_back", _wrap_Concentrating1dMesherPointVector_back, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_assign", _wrap_Concentrating1dMesherPointVector_assign, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_resize", _wrap_Concentrating1dMesherPointVector_resize, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_insert", _wrap_Concentrating1dMesherPointVector_insert, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_reserve", _wrap_Concentrating1dMesherPointVector_reserve, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_capacity", _wrap_Concentrating1dMesherPointVector_capacity, METH_O, NULL},
	 { "delete_Concentrating1dMesherPointVector", _wrap_delete_Concentrating1dMesherPointVector, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_swigregister", Concentrating1dMesherPointVector_swigregister, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_swiginit", Concentrating1dMesherPointVector_swiginit, METH_VARARGS, NULL},
	 { "new_Concentrating1dMesher", _wrap_new_Concentrating1dMesher, METH_VARARGS, NULL},
	 { "delete_Concentrating1dMesher", _wrap_delete_Concentrating1dMesher, METH_O, NULL},
	 { "Concentrating1dMesher_swigregister", Concentrating1dMesher_swigregister, METH_O, NULL},
	 { "Concentrating1dMesher_swiginit", Concentrating1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_ExponentialJump1dMesher", _wrap_new_ExponentialJump1dMesher, METH_VARARGS, NULL},
	 { "delete_ExponentialJump1dMesher", _wrap_delete_ExponentialJump1dMesher, METH_O, NULL},
	 { "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, NULL},
	 { "delete_FdmCEV1dMesher", _wrap_delete_FdmCEV1dMesher, METH_O, NULL},
	 { "FdmCEV1dMesher_swigregister", FdmCEV1dMesher_swigregister, METH_O, NULL},
	 { "FdmCEV1dMesher_swiginit", FdmCEV1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonVarianceMesher", _wrap_new_FdmHestonVarianceMesher, METH_VARARGS, NULL},
	 { "FdmHestonVarianceMesher_volaEstimate", _wrap_FdmHestonVarianceMesher_volaEstimate, METH_O, NULL},
	 { "delete_FdmHestonVarianceMesher", _wrap_delete_FdmHestonVarianceMesher, METH_O, NULL},
	 { "FdmHestonVarianceMesher_swigregister", FdmHestonVarianceMesher_swigregister, METH_O, NULL},
	 { "FdmHestonVarianceMesher_swiginit", FdmHestonVarianceMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonLocalVolatilityVarianceMesher", _wrap_new_FdmHestonLocalVolatilityVarianceMesher, METH_VARARGS, NULL},
	 { "FdmHestonLocalVolatilityVarianceMesher_volaEstimate", _wrap_FdmHestonLocalVolatilityVarianceMesher_volaEstimate, METH_O, NULL},
	 { "delete_FdmHestonLocalVolatilityVarianceMesher", _wrap_delete_FdmHestonLocalVolatilityVarianceMesher, METH_O, NULL},
	 { "FdmHestonLocalVolatilityVarianceMesher_swigregister", FdmHestonLocalVolatilityVarianceMesher_swigregister, METH_O, NULL},
	 { "FdmHestonLocalVolatilityVarianceMesher_swiginit", FdmHestonLocalVolatilityVarianceMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSimpleProcess1dMesher", _wrap_new_FdmSimpleProcess1dMesher, METH_VARARGS, NULL},
	 { "delete_FdmSimpleProcess1dMesher", _wrap_delete_FdmSimpleProcess1dMesher, METH_O, NULL},
	 { "FdmSimpleProcess1dMesher_swigregister", FdmSimpleProcess1dMesher_swigregister, METH_O, NULL},
	 { "FdmSimpleProcess1dMesher_swiginit", FdmSimpleProcess1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Uniform1dMesher", _wrap_new_Uniform1dMesher, METH_VARARGS, NULL},
	 { "delete_Uniform1dMesher", _wrap_delete_Uniform1dMesher, METH_O, NULL},
	 { "Uniform1dMesher_swigregister", Uniform1dMesher_swigregister, METH_O, NULL},
	 { "Uniform1dMesher_swiginit", Uniform1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Predefined1dMesher", _wrap_new_Predefined1dMesher, METH_O, NULL},
	 { "delete_Predefined1dMesher", _wrap_delete_Predefined1dMesher, METH_O, NULL},
	 { "Predefined1dMesher_swigregister", Predefined1dMesher_swigregister, METH_O, NULL},
	 { "Predefined1dMesher_swiginit", Predefined1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Glued1dMesher", _wrap_new_Glued1dMesher, METH_VARARGS, NULL},
	 { "delete_Glued1dMesher", _wrap_delete_Glued1dMesher, METH_O, NULL},
	 { "Glued1dMesher_swigregister", Glued1dMesher_swigregister, METH_O, NULL},
	 { "Glued1dMesher_swiginit", Glued1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLinearOpIterator", _wrap_new_FdmLinearOpIterator, METH_VARARGS, NULL},
	 { "FdmLinearOpIterator_coordinates", _wrap_FdmLinearOpIterator_coordinates, METH_O, NULL},
	 { "FdmLinearOpIterator_increment", _wrap_FdmLinearOpIterator_increment, METH_O, NULL},
	 { "FdmLinearOpIterator_notEqual", _wrap_FdmLinearOpIterator_notEqual, METH_VARARGS, NULL},
	 { "FdmLinearOpIterator_index", _wrap_FdmLinearOpIterator_index, METH_O, NULL},
	 { "delete_FdmLinearOpIterator", _wrap_delete_FdmLinearOpIterator, METH_O, NULL},
	 { "FdmLinearOpIterator_swigregister", FdmLinearOpIterator_swigregister, METH_O, NULL},
	 { "FdmLinearOpIterator_swiginit", FdmLinearOpIterator_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLinearOpLayout", _wrap_new_FdmLinearOpLayout, METH_O, NULL},
	 { "FdmLinearOpLayout_spacing", _wrap_FdmLinearOpLayout_spacing, METH_O, NULL},
	 { "FdmLinearOpLayout_dim", _wrap_FdmLinearOpLayout_dim, METH_O, NULL},
	 { "FdmLinearOpLayout_index", _wrap_FdmLinearOpLayout_index, METH_VARARGS, NULL},
	 { "FdmLinearOpLayout_begin", _wrap_FdmLinearOpLayout_begin, METH_O, NULL},
	 { "FdmLinearOpLayout_end", _wrap_FdmLinearOpLayout_end, METH_O, NULL},
	 { "FdmLinearOpLayout_size", _wrap_FdmLinearOpLayout_size, METH_O, NULL},
	 { "FdmLinearOpLayout_neighbourhood", _wrap_FdmLinearOpLayout_neighbourhood, METH_VARARGS, NULL},
	 { "FdmLinearOpLayout_iter_neighbourhood", _wrap_FdmLinearOpLayout_iter_neighbourhood, METH_VARARGS, NULL},
	 { "delete_FdmLinearOpLayout", _wrap_delete_FdmLinearOpLayout, METH_O, NULL},
	 { "FdmLinearOpLayout_swigregister", FdmLinearOpLayout_swigregister, METH_O, NULL},
	 { "FdmLinearOpLayout_swiginit", FdmLinearOpLayout_swiginit, METH_VARARGS, NULL},
	 { "delete_FdmMesher", _wrap_delete_FdmMesher, METH_O, NULL},
	 { "FdmMesher_swigregister", FdmMesher_swigregister, METH_O, NULL},
	 { "new_FdmMesherComposite", _wrap_new_FdmMesherComposite, METH_VARARGS, NULL},
	 { "FdmMesherComposite_dplus", _wrap_FdmMesherComposite_dplus, METH_VARARGS, NULL},
	 { "FdmMesherComposite_dminus", _wrap_FdmMesherComposite_dminus, METH_VARARGS, NULL},
	 { "FdmMesherComposite_location", _wrap_FdmMesherComposite_location, METH_VARARGS, NULL},
	 { "FdmMesherComposite_locations", _wrap_FdmMesherComposite_locations, METH_VARARGS, NULL},
	 { "FdmMesherComposite_layout", _wrap_FdmMesherComposite_layout, METH_O, NULL},
	 { "FdmMesherComposite_getFdm1dMeshers", _wrap_FdmMesherComposite_getFdm1dMeshers, METH_O, NULL},
	 { "delete_FdmMesherComposite", _wrap_delete_FdmMesherComposite, METH_O, NULL},
	 { "FdmMesherComposite_swigregister", FdmMesherComposite_swigregister, METH_O, NULL},
	 { "FdmMesherComposite_swiginit", FdmMesherComposite_swiginit, METH_VARARGS, NULL},
	 { "FdmLinearOp_apply", _wrap_FdmLinearOp_apply, METH_VARARGS, NULL},
	 { "delete_FdmLinearOp", _wrap_delete_FdmLinearOp, METH_O, NULL},
	 { "FdmLinearOp_swigregister", FdmLinearOp_swigregister, METH_O, NULL},
	 { "FdmLinearOpComposite_size", _wrap_FdmLinearOpComposite_size, METH_O, NULL},
	 { "FdmLinearOpComposite_setTime", _wrap_FdmLinearOpComposite_setTime, METH_VARARGS, NULL},
	 { "FdmLinearOpComposite_apply_mixed", _wrap_FdmLinearOpComposite_apply_mixed, METH_VARARGS, NULL},
	 { "FdmLinearOpComposite_apply_direction", _wrap_FdmLinearOpComposite_apply_direction, METH_VARARGS, NULL},
	 { "FdmLinearOpComposite_solve_splitting", _wrap_FdmLinearOpComposite_solve_splitting, METH_VARARGS, NULL},
	 { "FdmLinearOpComposite_preconditioner", _wrap_FdmLinearOpComposite_preconditioner, METH_VARARGS, NULL},
	 { "delete_FdmLinearOpComposite", _wrap_delete_FdmLinearOpComposite, METH_O, NULL},
	 { "FdmLinearOpComposite_swigregister", FdmLinearOpComposite_swigregister, METH_O, NULL},
	 { "new_FdmLinearOpCompositeProxy", _wrap_new_FdmLinearOpCompositeProxy, METH_O, NULL},
	 { "delete_FdmLinearOpCompositeProxy", _wrap_delete_FdmLinearOpCompositeProxy, METH_O, NULL},
	 { "FdmLinearOpCompositeProxy_swigregister", FdmLinearOpCompositeProxy_swigregister, METH_O, NULL},
	 { "FdmLinearOpCompositeProxy_swiginit", FdmLinearOpCompositeProxy_swiginit, METH_VARARGS, NULL},
	 { "FdmBoundaryCondition_applyBeforeApplying", _wrap_FdmBoundaryCondition_applyBeforeApplying, METH_VARARGS, NULL},
	 { "FdmBoundaryCondition_applyAfterApplying", _wrap_FdmBoundaryCondition_applyAfterApplying, METH_VARARGS, NULL},
	 { "FdmBoundaryCondition_applyBeforeSolving", _wrap_FdmBoundaryCondition_applyBeforeSolving, METH_VARARGS, NULL},
	 { "FdmBoundaryCondition_applyAfterSolving", _wrap_FdmBoundaryCondition_applyAfterSolving, METH_VARARGS, NULL},
	 { "FdmBoundaryCondition_setTime", _wrap_FdmBoundaryCondition_setTime, METH_VARARGS, NULL},
	 { "delete_FdmBoundaryCondition", _wrap_delete_FdmBoundaryCondition, METH_O, NULL},
	 { "FdmBoundaryCondition_swigregister", FdmBoundaryCondition_swigregister, METH_O, NULL},
	 { "FdmBoundaryConditionSet_iterator", _wrap_FdmBoundaryConditionSet_iterator, METH_O, NULL},
	 { "FdmBoundaryConditionSet___nonzero__", _wrap_FdmBoundaryConditionSet___nonzero__, METH_O, NULL},
	 { "FdmBoundaryConditionSet___bool__", _wrap_FdmBoundaryConditionSet___bool__, METH_O, NULL},
	 { "FdmBoundaryConditionSet___len__", _wrap_FdmBoundaryConditionSet___len__, METH_O, NULL},
	 { "FdmBoundaryConditionSet___getslice__", _wrap_FdmBoundaryConditionSet___getslice__, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet___setslice__", _wrap_FdmBoundaryConditionSet___setslice__, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet___delslice__", _wrap_FdmBoundaryConditionSet___delslice__, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet___delitem__", _wrap_FdmBoundaryConditionSet___delitem__, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet___getitem__", _wrap_FdmBoundaryConditionSet___getitem__, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet___setitem__", _wrap_FdmBoundaryConditionSet___setitem__, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_pop", _wrap_FdmBoundaryConditionSet_pop, METH_O, NULL},
	 { "FdmBoundaryConditionSet_append", _wrap_FdmBoundaryConditionSet_append, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_empty", _wrap_FdmBoundaryConditionSet_empty, METH_O, NULL},
	 { "FdmBoundaryConditionSet_size", _wrap_FdmBoundaryConditionSet_size, METH_O, NULL},
	 { "FdmBoundaryConditionSet_swap", _wrap_FdmBoundaryConditionSet_swap, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_begin", _wrap_FdmBoundaryConditionSet_begin, METH_O, NULL},
	 { "FdmBoundaryConditionSet_end", _wrap_FdmBoundaryConditionSet_end, METH_O, NULL},
	 { "FdmBoundaryConditionSet_rbegin", _wrap_FdmBoundaryConditionSet_rbegin, METH_O, NULL},
	 { "FdmBoundaryConditionSet_rend", _wrap_FdmBoundaryConditionSet_rend, METH_O, NULL},
	 { "FdmBoundaryConditionSet_clear", _wrap_FdmBoundaryConditionSet_clear, METH_O, NULL},
	 { "FdmBoundaryConditionSet_get_allocator", _wrap_FdmBoundaryConditionSet_get_allocator, METH_O, NULL},
	 { "FdmBoundaryConditionSet_pop_back", _wrap_FdmBoundaryConditionSet_pop_back, METH_O, NULL},
	 { "FdmBoundaryConditionSet_erase", _wrap_FdmBoundaryConditionSet_erase, METH_VARARGS, NULL},
	 { "new_FdmBoundaryConditionSet", _wrap_new_FdmBoundaryConditionSet, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_push_back", _wrap_FdmBoundaryConditionSet_push_back, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_front", _wrap_FdmBoundaryConditionSet_front, METH_O, NULL},
	 { "FdmBoundaryConditionSet_back", _wrap_FdmBoundaryConditionSet_back, METH_O, NULL},
	 { "FdmBoundaryConditionSet_assign", _wrap_FdmBoundaryConditionSet_assign, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_resize", _wrap_FdmBoundaryConditionSet_resize, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_insert", _wrap_FdmBoundaryConditionSet_insert, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_reserve", _wrap_FdmBoundaryConditionSet_reserve, METH_VARARGS, NULL},
	 { "FdmBoundaryConditionSet_capacity", _wrap_FdmBoundaryConditionSet_capacity, METH_O, NULL},
	 { "delete_FdmBoundaryConditionSet", _wrap_delete_FdmBoundaryConditionSet, METH_O, NULL},
	 { "FdmBoundaryConditionSet_swigregister", FdmBoundaryConditionSet_swigregister, METH_O, NULL},
	 { "FdmBoundaryConditionSet_swiginit", FdmBoundaryConditionSet_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDirichletBoundary", _wrap_new_FdmDirichletBoundary, METH_VARARGS, NULL},
	 { "FdmDirichletBoundary_applyAfterApplying", _wrap_FdmDirichletBoundary_applyAfterApplying, METH_VARARGS, NULL},
	 { "delete_FdmDirichletBoundary", _wrap_delete_FdmDirichletBoundary, METH_O, NULL},
	 { "FdmDirichletBoundary_swigregister", FdmDirichletBoundary_swigregister, METH_O, NULL},
	 { "FdmDirichletBoundary_swiginit", FdmDirichletBoundary_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDiscountDirichletBoundary", _wrap_new_FdmDiscountDirichletBoundary, METH_VARARGS, NULL},
	 { "delete_FdmDiscountDirichletBoundary", _wrap_delete_FdmDiscountDirichletBoundary, METH_O, NULL},
	 { "FdmDiscountDirichletBoundary_swigregister", FdmDiscountDirichletBoundary_swigregister, METH_O, NULL},
	 { "FdmDiscountDirichletBoundary_swiginit", FdmDiscountDirichletBoundary_swiginit, METH_VARARGS, NULL},
	 { "new_FdmTimeDepDirichletBoundary", _wrap_new_FdmTimeDepDirichletBoundary, METH_VARARGS, NULL},
	 { "delete_FdmTimeDepDirichletBoundary", _wrap_delete_FdmTimeDepDirichletBoundary, METH_O, NULL},
	 { "FdmTimeDepDirichletBoundary_swigregister", FdmTimeDepDirichletBoundary_swigregister, METH_O, NULL},
	 { "FdmTimeDepDirichletBoundary_swiginit", FdmTimeDepDirichletBoundary_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBatesOp", _wrap_new_FdmBatesOp, METH_VARARGS, NULL},
	 { "delete_FdmBatesOp", _wrap_delete_FdmBatesOp, METH_O, NULL},
	 { "FdmBatesOp_swigregister", FdmBatesOp_swigregister, METH_O, NULL},
	 { "FdmBatesOp_swiginit", FdmBatesOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBlackScholesOp", _wrap_new_FdmBlackScholesOp, METH_VARARGS, NULL},
	 { "delete_FdmBlackScholesOp", _wrap_delete_FdmBlackScholesOp, METH_O, NULL},
	 { "FdmBlackScholesOp_swigregister", FdmBlackScholesOp_swigregister, METH_O, NULL},
	 { "FdmBlackScholesOp_swiginit", FdmBlackScholesOp_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm2dBlackScholesOp", _wrap_new_Fdm2dBlackScholesOp, METH_VARARGS, NULL},
	 { "delete_Fdm2dBlackScholesOp", _wrap_delete_Fdm2dBlackScholesOp, METH_O, NULL},
	 { "Fdm2dBlackScholesOp_swigregister", Fdm2dBlackScholesOp_swigregister, METH_O, NULL},
	 { "Fdm2dBlackScholesOp_swiginit", Fdm2dBlackScholesOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmCEVOp", _wrap_new_FdmCEVOp, METH_VARARGS, NULL},
	 { "delete_FdmCEVOp", _wrap_delete_FdmCEVOp, METH_O, NULL},
	 { "FdmCEVOp_swigregister", FdmCEVOp_swigregister, METH_O, NULL},
	 { "FdmCEVOp_swiginit", FdmCEVOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmG2Op", _wrap_new_FdmG2Op, METH_VARARGS, NULL},
	 { "delete_FdmG2Op", _wrap_delete_FdmG2Op, METH_O, NULL},
	 { "FdmG2Op_swigregister", FdmG2Op_swigregister, METH_O, NULL},
	 { "FdmG2Op_swiginit", FdmG2Op_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonHullWhiteOp", _wrap_new_FdmHestonHullWhiteOp, METH_VARARGS, NULL},
	 { "delete_FdmHestonHullWhiteOp", _wrap_delete_FdmHestonHullWhiteOp, METH_O, NULL},
	 { "FdmHestonHullWhiteOp_swigregister", FdmHestonHullWhiteOp_swigregister, METH_O, NULL},
	 { "FdmHestonHullWhiteOp_swiginit", FdmHestonHullWhiteOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonOp", _wrap_new_FdmHestonOp, METH_VARARGS, NULL},
	 { "delete_FdmHestonOp", _wrap_delete_FdmHestonOp, METH_O, NULL},
	 { "FdmHestonOp_swigregister", FdmHestonOp_swigregister, METH_O, NULL},
	 { "FdmHestonOp_swiginit", FdmHestonOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHullWhiteOp", _wrap_new_FdmHullWhiteOp, METH_VARARGS, NULL},
	 { "delete_FdmHullWhiteOp", _wrap_delete_FdmHullWhiteOp, METH_O, NULL},
	 { "FdmHullWhiteOp_swigregister", FdmHullWhiteOp_swigregister, METH_O, NULL},
	 { "FdmHullWhiteOp_swiginit", FdmHullWhiteOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLocalVolFwdOp", _wrap_new_FdmLocalVolFwdOp, METH_VARARGS, NULL},
	 { "delete_FdmLocalVolFwdOp", _wrap_delete_FdmLocalVolFwdOp, METH_O, NULL},
	 { "FdmLocalVolFwdOp_swigregister", FdmLocalVolFwdOp_swigregister, METH_O, NULL},
	 { "FdmLocalVolFwdOp_swiginit", FdmLocalVolFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmOrnsteinUhlenbeckOp", _wrap_new_FdmOrnsteinUhlenbeckOp, METH_VARARGS, NULL},
	 { "delete_FdmOrnsteinUhlenbeckOp", _wrap_delete_FdmOrnsteinUhlenbeckOp, METH_O, NULL},
	 { "FdmOrnsteinUhlenbeckOp_swigregister", FdmOrnsteinUhlenbeckOp_swigregister, METH_O, NULL},
	 { "FdmOrnsteinUhlenbeckOp_swiginit", FdmOrnsteinUhlenbeckOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSabrOp", _wrap_new_FdmSabrOp, METH_VARARGS, NULL},
	 { "delete_FdmSabrOp", _wrap_delete_FdmSabrOp, METH_O, NULL},
	 { "FdmSabrOp_swigregister", FdmSabrOp_swigregister, METH_O, NULL},
	 { "FdmSabrOp_swiginit", FdmSabrOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmZabrOp", _wrap_new_FdmZabrOp, METH_VARARGS, NULL},
	 { "delete_FdmZabrOp", _wrap_delete_FdmZabrOp, METH_O, NULL},
	 { "FdmZabrOp_swigregister", FdmZabrOp_swigregister, METH_O, NULL},
	 { "FdmZabrOp_swiginit", FdmZabrOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDupire1dOp", _wrap_new_FdmDupire1dOp, METH_VARARGS, NULL},
	 { "delete_FdmDupire1dOp", _wrap_delete_FdmDupire1dOp, METH_O, NULL},
	 { "FdmDupire1dOp_swigregister", FdmDupire1dOp_swigregister, METH_O, NULL},
	 { "FdmDupire1dOp_swiginit", FdmDupire1dOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBlackScholesFwdOp", _wrap_new_FdmBlackScholesFwdOp, METH_VARARGS, NULL},
	 { "delete_FdmBlackScholesFwdOp", _wrap_delete_FdmBlackScholesFwdOp, METH_O, NULL},
	 { "FdmBlackScholesFwdOp_swigregister", FdmBlackScholesFwdOp_swigregister, METH_O, NULL},
	 { "FdmBlackScholesFwdOp_swiginit", FdmBlackScholesFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSquareRootFwdOp", _wrap_new_FdmSquareRootFwdOp, METH_VARARGS, NULL},
	 { "delete_FdmSquareRootFwdOp", _wrap_delete_FdmSquareRootFwdOp, METH_O, NULL},
	 { "FdmSquareRootFwdOp_swigregister", FdmSquareRootFwdOp_swigregister, METH_O, NULL},
	 { "FdmSquareRootFwdOp_swiginit", FdmSquareRootFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonFwdOp", _wrap_new_FdmHestonFwdOp, METH_VARARGS, NULL},
	 { "delete_FdmHestonFwdOp", _wrap_delete_FdmHestonFwdOp, METH_O, NULL},
	 { "FdmHestonFwdOp_swigregister", FdmHestonFwdOp_swigregister, METH_O, NULL},
	 { "FdmHestonFwdOp_swiginit", FdmHestonFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_TripleBandLinearOp", _wrap_new_TripleBandLinearOp, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_apply", _wrap_TripleBandLinearOp_apply, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_solve_splitting", _wrap_TripleBandLinearOp_solve_splitting, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_mult", _wrap_TripleBandLinearOp_mult, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_multR", _wrap_TripleBandLinearOp_multR, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_add", _wrap_TripleBandLinearOp_add, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_axpyb", _wrap_TripleBandLinearOp_axpyb, METH_VARARGS, NULL},
	 { "TripleBandLinearOp_swap", _wrap_TripleBandLinearOp_swap, METH_VARARGS, NULL},
	 { "delete_TripleBandLinearOp", _wrap_delete_TripleBandLinearOp, METH_O, NULL},
	 { "TripleBandLinearOp_swigregister", TripleBandLinearOp_swigregister, METH_O, NULL},
	 { "TripleBandLinearOp_swiginit", TripleBandLinearOp_swiginit, METH_VARARGS, NULL},
	 { "new_FirstDerivativeOp", _wrap_new_FirstDerivativeOp, METH_VARARGS, NULL},
	 { "delete_FirstDerivativeOp", _wrap_delete_FirstDerivativeOp, METH_O, NULL},
	 { "FirstDerivativeOp_swigregister", FirstDerivativeOp_swigregister, METH_O, NULL},
	 { "FirstDerivativeOp_swiginit", FirstDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_SecondDerivativeOp", _wrap_new_SecondDerivativeOp, METH_VARARGS, NULL},
	 { "delete_SecondDerivativeOp", _wrap_delete_SecondDerivativeOp, METH_O, NULL},
	 { "SecondDerivativeOp_swigregister", SecondDerivativeOp_swigregister, METH_O, NULL},
	 { "SecondDerivativeOp_swiginit", SecondDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_NinePointLinearOp", _wrap_new_NinePointLinearOp, METH_VARARGS, NULL},
	 { "delete_NinePointLinearOp", _wrap_delete_NinePointLinearOp, METH_O, NULL},
	 { "NinePointLinearOp_swigregister", NinePointLinearOp_swigregister, METH_O, NULL},
	 { "NinePointLinearOp_swiginit", NinePointLinearOp_swiginit, METH_VARARGS, NULL},
	 { "new_SecondOrderMixedDerivativeOp", _wrap_new_SecondOrderMixedDerivativeOp, METH_VARARGS, NULL},
	 { "delete_SecondOrderMixedDerivativeOp", _wrap_delete_SecondOrderMixedDerivativeOp, METH_O, NULL},
	 { "SecondOrderMixedDerivativeOp_swigregister", SecondOrderMixedDerivativeOp_swigregister, METH_O, NULL},
	 { "SecondOrderMixedDerivativeOp_swiginit", SecondOrderMixedDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_NthOrderDerivativeOp", _wrap_new_NthOrderDerivativeOp, METH_VARARGS, NULL},
	 { "delete_NthOrderDerivativeOp", _wrap_delete_NthOrderDerivativeOp, METH_O, NULL},
	 { "NthOrderDerivativeOp_swigregister", NthOrderDerivativeOp_swigregister, METH_O, NULL},
	 { "NthOrderDerivativeOp_swiginit", NthOrderDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_CraigSneydScheme", _wrap_new_CraigSneydScheme, METH_VARARGS, NULL},
	 { "CraigSneydScheme_step", _wrap_CraigSneydScheme_step, METH_VARARGS, NULL},
	 { "CraigSneydScheme_setStep", _wrap_CraigSneydScheme_setStep, METH_VARARGS, NULL},
	 { "delete_CraigSneydScheme", _wrap_delete_CraigSneydScheme, METH_O, NULL},
	 { "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, NULL},
	 { "ImplicitEulerScheme_step", _wrap_ImplicitEulerScheme_step, METH_VARARGS, NULL},
	 { "ImplicitEulerScheme_setStep", _wrap_ImplicitEulerScheme_setStep, METH_VARARGS, NULL},
	 { "ImplicitEulerScheme_numberOfIterations", _wrap_ImplicitEulerScheme_numberOfIterations, METH_O, NULL},
	 { "delete_ImplicitEulerScheme", _wrap_delete_ImplicitEulerScheme, METH_O, NULL},
	 { "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, NULL},
	 { "CrankNicolsonScheme_step", _wrap_CrankNicolsonScheme_step, METH_VARARGS, NULL},
	 { "CrankNicolsonScheme_setStep", _wrap_CrankNicolsonScheme_setStep, METH_VARARGS, NULL},
	 { "CrankNicolsonScheme_numberOfIterations", _wrap_CrankNicolsonScheme_numberOfIterations, METH_O, NULL},
	 { "delete_CrankNicolsonScheme", _wrap_delete_CrankNicolsonScheme, METH_O, NULL},
	 { "CrankNicolsonScheme_swigregister", CrankNicolsonScheme_swigregister, METH_O, NULL},
	 { "CrankNicolsonScheme_swiginit", CrankNicolsonScheme_swiginit, METH_VARARGS, NULL},
	 { "new_DouglasScheme", _wrap_new_DouglasScheme, METH_VARARGS, NULL},
	 { "DouglasScheme_step", _wrap_DouglasScheme_step, METH_VARARGS, NULL},
	 { "DouglasScheme_setStep", _wrap_DouglasScheme_setStep, METH_VARARGS, NULL},
	 { "delete_DouglasScheme", _wrap_delete_DouglasScheme, METH_O, NULL},
	 { "DouglasScheme_swigregister", DouglasScheme_swigregister, METH_O, NULL},
	 { "DouglasScheme_swiginit", DouglasScheme_swiginit, METH_VARARGS, NULL},
	 { "new_ExplicitEulerScheme", _wrap_new_ExplicitEulerScheme, METH_VARARGS, NULL},
	 { "ExplicitEulerScheme_step", _wrap_ExplicitEulerScheme_step, METH_VARARGS, NULL},
	 { "ExplicitEulerScheme_setStep", _wrap_ExplicitEulerScheme_setStep, METH_VARARGS, NULL},
	 { "delete_ExplicitEulerScheme", _wrap_delete_ExplicitEulerScheme, METH_O, NULL},
	 { "ExplicitEulerScheme_swigregister", ExplicitEulerScheme_swigregister, METH_O, NULL},
	 { "ExplicitEulerScheme_swiginit", ExplicitEulerScheme_swiginit, METH_VARARGS, NULL},
	 { "new_HundsdorferScheme", _wrap_new_HundsdorferScheme, METH_VARARGS, NULL},
	 { "HundsdorferScheme_step", _wrap_HundsdorferScheme_step, METH_VARARGS, NULL},
	 { "HundsdorferScheme_setStep", _wrap_HundsdorferScheme_setStep, METH_VARARGS, NULL},
	 { "delete_HundsdorferScheme", _wrap_delete_HundsdorferScheme, METH_O, NULL},
	 { "HundsdorferScheme_swigregister", HundsdorferScheme_swigregister, METH_O, NULL},
	 { "HundsdorferScheme_swiginit", HundsdorferScheme_swiginit, METH_VARARGS, NULL},
	 { "new_MethodOfLinesScheme", _wrap_new_MethodOfLinesScheme, METH_VARARGS, NULL},
	 { "MethodOfLinesScheme_step", _wrap_MethodOfLinesScheme_step, METH_VARARGS, NULL},
	 { "MethodOfLinesScheme_setStep", _wrap_MethodOfLinesScheme_setStep, METH_VARARGS, NULL},
	 { "delete_MethodOfLinesScheme", _wrap_delete_MethodOfLinesScheme, METH_O, NULL},
	 { "MethodOfLinesScheme_swigregister", MethodOfLinesScheme_swigregister, METH_O, NULL},
	 { "MethodOfLinesScheme_swiginit", MethodOfLinesScheme_swiginit, METH_VARARGS, NULL},
	 { "new_ModifiedCraigSneydScheme", _wrap_new_ModifiedCraigSneydScheme, METH_VARARGS, NULL},
	 { "ModifiedCraigSneydScheme_step", _wrap_ModifiedCraigSneydScheme_step, METH_VARARGS, NULL},
	 { "ModifiedCraigSneydScheme_setStep", _wrap_ModifiedCraigSneydScheme_setStep, METH_VARARGS, NULL},
	 { "delete_ModifiedCraigSneydScheme", _wrap_delete_ModifiedCraigSneydScheme, METH_O, NULL},
	 { "ModifiedCraigSneydScheme_swigregister", ModifiedCraigSneydScheme_swigregister, METH_O, NULL},
	 { "ModifiedCraigSneydScheme_swiginit", ModifiedCraigSneydScheme_swiginit, METH_VARARGS, NULL},
	 { "FdmStepCondition_applyTo", _wrap_FdmStepCondition_applyTo, METH_VARARGS, NULL},
	 { "delete_FdmStepCondition", _wrap_delete_FdmStepCondition, METH_O, NULL},
	 { "FdmStepCondition_swigregister", FdmStepCondition_swigregister, METH_O, NULL},
	 { "new_FdmStepConditionProxy", _wrap_new_FdmStepConditionProxy, METH_O, NULL},
	 { "delete_FdmStepConditionProxy", _wrap_delete_FdmStepConditionProxy, METH_O, NULL},
	 { "FdmStepConditionProxy_swigregister", FdmStepConditionProxy_swigregister, METH_O, NULL},
	 { "FdmStepConditionProxy_swiginit", FdmStepConditionProxy_swiginit, METH_VARARGS, NULL},
	 { "FdmInnerValueCalculator_innerValue", _wrap_FdmInnerValueCalculator_innerValue, METH_VARARGS, NULL},
	 { "FdmInnerValueCalculator_avgInnerValue", _wrap_FdmInnerValueCalculator_avgInnerValue, METH_VARARGS, NULL},
	 { "delete_FdmInnerValueCalculator", _wrap_delete_FdmInnerValueCalculator, METH_O, NULL},
	 { "FdmInnerValueCalculator_swigregister", FdmInnerValueCalculator_swigregister, METH_O, NULL},
	 { "new_FdmInnerValueCalculatorProxy", _wrap_new_FdmInnerValueCalculatorProxy, METH_O, NULL},
	 { "delete_FdmInnerValueCalculatorProxy", _wrap_delete_FdmInnerValueCalculatorProxy, METH_O, NULL},
	 { "FdmInnerValueCalculatorProxy_swigregister", FdmInnerValueCalculatorProxy_swigregister, METH_O, NULL},
	 { "FdmInnerValueCalculatorProxy_swiginit", FdmInnerValueCalculatorProxy_swiginit, METH_VARARGS, NULL},
	 { "new_FdmCellAveragingInnerValue", _wrap_new_FdmCellAveragingInnerValue, METH_VARARGS, NULL},
	 { "delete_FdmCellAveragingInnerValue", _wrap_delete_FdmCellAveragingInnerValue, METH_O, NULL},
	 { "FdmCellAveragingInnerValue_swigregister", FdmCellAveragingInnerValue_swigregister, METH_O, NULL},
	 { "FdmCellAveragingInnerValue_swiginit", FdmCellAveragingInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLogInnerValue", _wrap_new_FdmLogInnerValue, METH_VARARGS, NULL},
	 { "delete_FdmLogInnerValue", _wrap_delete_FdmLogInnerValue, METH_O, NULL},
	 { "FdmLogInnerValue_swigregister", FdmLogInnerValue_swigregister, METH_O, NULL},
	 { "FdmLogInnerValue_swiginit", FdmLogInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLogBasketInnerValue", _wrap_new_FdmLogBasketInnerValue, METH_VARARGS, NULL},
	 { "delete_FdmLogBasketInnerValue", _wrap_delete_FdmLogBasketInnerValue, METH_O, NULL},
	 { "FdmLogBasketInnerValue_swigregister", FdmLogBasketInnerValue_swigregister, METH_O, NULL},
	 { "FdmLogBasketInnerValue_swiginit", FdmLogBasketInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmZeroInnerValue", _wrap_new_FdmZeroInnerValue, METH_NOARGS, NULL},
	 { "delete_FdmZeroInnerValue", _wrap_delete_FdmZeroInnerValue, METH_O, NULL},
	 { "FdmZeroInnerValue_swigregister", FdmZeroInnerValue_swigregister, METH_O, NULL},
	 { "FdmZeroInnerValue_swiginit", FdmZeroInnerValue_swiginit, METH_VARARGS, NULL},
	 { "TimeToDateMap_iterator", _wrap_TimeToDateMap_iterator, METH_O, NULL},
	 { "TimeToDateMap___nonzero__", _wrap_TimeToDateMap___nonzero__, METH_O, NULL},
	 { "TimeToDateMap___bool__", _wrap_TimeToDateMap___bool__, METH_O, NULL},
	 { "TimeToDateMap___len__", _wrap_TimeToDateMap___len__, METH_O, NULL},
	 { "TimeToDateMap___getitem__", _wrap_TimeToDateMap___getitem__, METH_VARARGS, NULL},
	 { "TimeToDateMap___delitem__", _wrap_TimeToDateMap___delitem__, METH_VARARGS, NULL},
	 { "TimeToDateMap_has_key", _wrap_TimeToDateMap_has_key, METH_VARARGS, NULL},
	 { "TimeToDateMap_keys", _wrap_TimeToDateMap_keys, METH_O, NULL},
	 { "TimeToDateMap_values", _wrap_TimeToDateMap_values, METH_O, NULL},
	 { "TimeToDateMap_items", _wrap_TimeToDateMap_items, METH_O, NULL},
	 { "TimeToDateMap___contains__", _wrap_TimeToDateMap___contains__, METH_VARARGS, NULL},
	 { "TimeToDateMap_key_iterator", _wrap_TimeToDateMap_key_iterator, METH_O, NULL},
	 { "TimeToDateMap_value_iterator", _wrap_TimeToDateMap_value_iterator, METH_O, NULL},
	 { "TimeToDateMap___setitem__", _wrap_TimeToDateMap___setitem__, METH_VARARGS, NULL},
	 { "TimeToDateMap_asdict", _wrap_TimeToDateMap_asdict, METH_O, NULL},
	 { "new_TimeToDateMap", _wrap_new_TimeToDateMap, METH_VARARGS, NULL},
	 { "TimeToDateMap_empty", _wrap_TimeToDateMap_empty, METH_O, NULL},
	 { "TimeToDateMap_size", _wrap_TimeToDateMap_size, METH_O, NULL},
	 { "TimeToDateMap_swap", _wrap_TimeToDateMap_swap, METH_VARARGS, NULL},
	 { "TimeToDateMap_begin", _wrap_TimeToDateMap_begin, METH_O, NULL},
	 { "TimeToDateMap_end", _wrap_TimeToDateMap_end, METH_O, NULL},
	 { "TimeToDateMap_rbegin", _wrap_TimeToDateMap_rbegin, METH_O, NULL},
	 { "TimeToDateMap_rend", _wrap_TimeToDateMap_rend, METH_O, NULL},
	 { "TimeToDateMap_clear", _wrap_TimeToDateMap_clear, METH_O, NULL},
	 { "TimeToDateMap_get_allocator", _wrap_TimeToDateMap_get_allocator, METH_O, NULL},
	 { "TimeToDateMap_count", _wrap_TimeToDateMap_count, METH_VARARGS, NULL},
	 { "TimeToDateMap_erase", _wrap_TimeToDateMap_erase, METH_VARARGS, NULL},
	 { "TimeToDateMap_find", _wrap_TimeToDateMap_find, METH_VARARGS, NULL},
	 { "TimeToDateMap_lower_bound", _wrap_TimeToDateMap_lower_bound, METH_VARARGS, NULL},
	 { "TimeToDateMap_upper_bound", _wrap_TimeToDateMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_TimeToDateMap", _wrap_delete_TimeToDateMap, METH_O, NULL},
	 { "TimeToDateMap_swigregister", TimeToDateMap_swigregister, METH_O, NULL},
	 { "TimeToDateMap_swiginit", TimeToDateMap_swiginit, METH_VARARGS, NULL},
	 { "new_FdmAffineG2ModelSwapInnerValue", _wrap_new_FdmAffineG2ModelSwapInnerValue, METH_VARARGS, NULL},
	 { "delete_FdmAffineG2ModelSwapInnerValue", _wrap_delete_FdmAffineG2ModelSwapInnerValue, METH_O, NULL},
	 { "FdmAffineG2ModelSwapInnerValue_swigregister", FdmAffineG2ModelSwapInnerValue_swigregister, METH_O, NULL},
	 { "FdmAffineG2ModelSwapInnerValue_swiginit", FdmAffineG2ModelSwapInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmAffineHullWhiteModelSwapInnerValue", _wrap_new_FdmAffineHullWhiteModelSwapInnerValue, METH_VARARGS, NULL},
	 { "delete_FdmAffineHullWhiteModelSwapInnerValue", _wrap_delete_FdmAffineHullWhiteModelSwapInnerValue, METH_O, NULL},
	 { "FdmAffineHullWhiteModelSwapInnerValue_swigregister", FdmAffineHullWhiteModelSwapInnerValue_swigregister, METH_O, NULL},
	 { "FdmAffineHullWhiteModelSwapInnerValue_swiginit", FdmAffineHullWhiteModelSwapInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSnapshotCondition", _wrap_new_FdmSnapshotCondition, METH_O, NULL},
	 { "FdmSnapshotCondition_getTime", _wrap_FdmSnapshotCondition_getTime, METH_O, NULL},
	 { "FdmSnapshotCondition_getValues", _wrap_FdmSnapshotCondition_getValues, METH_O, NULL},
	 { "delete_FdmSnapshotCondition", _wrap_delete_FdmSnapshotCondition, METH_O, NULL},
	 { "FdmSnapshotCondition_swigregister", FdmSnapshotCondition_swigregister, METH_O, NULL},
	 { "FdmSnapshotCondition_swiginit", FdmSnapshotCondition_swiginit, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_iterator", _wrap_FdmStepConditionVector_iterator, METH_O, NULL},
	 { "FdmStepConditionVector___nonzero__", _wrap_FdmStepConditionVector___nonzero__, METH_O, NULL},
	 { "FdmStepConditionVector___bool__", _wrap_FdmStepConditionVector___bool__, METH_O, NULL},
	 { "FdmStepConditionVector___len__", _wrap_FdmStepConditionVector___len__, METH_O, NULL},
	 { "FdmStepConditionVector___getslice__", _wrap_FdmStepConditionVector___getslice__, METH_VARARGS, NULL},
	 { "FdmStepConditionVector___setslice__", _wrap_FdmStepConditionVector___setslice__, METH_VARARGS, NULL},
	 { "FdmStepConditionVector___delslice__", _wrap_FdmStepConditionVector___delslice__, METH_VARARGS, NULL},
	 { "FdmStepConditionVector___delitem__", _wrap_FdmStepConditionVector___delitem__, METH_VARARGS, NULL},
	 { "FdmStepConditionVector___getitem__", _wrap_FdmStepConditionVector___getitem__, METH_VARARGS, NULL},
	 { "FdmStepConditionVector___setitem__", _wrap_FdmStepConditionVector___setitem__, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_pop", _wrap_FdmStepConditionVector_pop, METH_O, NULL},
	 { "FdmStepConditionVector_append", _wrap_FdmStepConditionVector_append, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_empty", _wrap_FdmStepConditionVector_empty, METH_O, NULL},
	 { "FdmStepConditionVector_size", _wrap_FdmStepConditionVector_size, METH_O, NULL},
	 { "FdmStepConditionVector_swap", _wrap_FdmStepConditionVector_swap, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_begin", _wrap_FdmStepConditionVector_begin, METH_O, NULL},
	 { "FdmStepConditionVector_end", _wrap_FdmStepConditionVector_end, METH_O, NULL},
	 { "FdmStepConditionVector_rbegin", _wrap_FdmStepConditionVector_rbegin, METH_O, NULL},
	 { "FdmStepConditionVector_rend", _wrap_FdmStepConditionVector_rend, METH_O, NULL},
	 { "FdmStepConditionVector_clear", _wrap_FdmStepConditionVector_clear, METH_O, NULL},
	 { "FdmStepConditionVector_get_allocator", _wrap_FdmStepConditionVector_get_allocator, METH_O, NULL},
	 { "FdmStepConditionVector_pop_back", _wrap_FdmStepConditionVector_pop_back, METH_O, NULL},
	 { "FdmStepConditionVector_erase", _wrap_FdmStepConditionVector_erase, METH_VARARGS, NULL},
	 { "new_FdmStepConditionVector", _wrap_new_FdmStepConditionVector, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_push_back", _wrap_FdmStepConditionVector_push_back, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_front", _wrap_FdmStepConditionVector_front, METH_O, NULL},
	 { "FdmStepConditionVector_back", _wrap_FdmStepConditionVector_back, METH_O, NULL},
	 { "FdmStepConditionVector_assign", _wrap_FdmStepConditionVector_assign, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_resize", _wrap_FdmStepConditionVector_resize, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_insert", _wrap_FdmStepConditionVector_insert, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_reserve", _wrap_FdmStepConditionVector_reserve, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_capacity", _wrap_FdmStepConditionVector_capacity, METH_O, NULL},
	 { "delete_FdmStepConditionVector", _wrap_delete_FdmStepConditionVector, METH_O, NULL},
	 { "FdmStepConditionVector_swigregister", FdmStepConditionVector_swigregister, METH_O, NULL},
	 { "FdmStepConditionVector_swiginit", FdmStepConditionVector_swiginit, METH_VARARGS, NULL},
	 { "new_FdmStepConditionComposite", _wrap_new_FdmStepConditionComposite, METH_VARARGS, NULL},
	 { "FdmStepConditionComposite_stoppingTimes", _wrap_FdmStepConditionComposite_stoppingTimes, METH_O, NULL},
	 { "FdmStepConditionComposite_conditions", _wrap_FdmStepConditionComposite_conditions, METH_O, NULL},
	 { "FdmStepConditionComposite_joinConditions", _wrap_FdmStepConditionComposite_joinConditions, METH_VARARGS, NULL},
	 { "FdmStepConditionComposite_vanillaComposite", _wrap_FdmStepConditionComposite_vanillaComposite, METH_VARARGS, NULL},
	 { "delete_FdmStepConditionComposite", _wrap_delete_FdmStepConditionComposite, METH_O, NULL},
	 { "FdmStepConditionComposite_swigregister", FdmStepConditionComposite_swigregister, METH_O, NULL},
	 { "FdmStepConditionComposite_swiginit", FdmStepConditionComposite_swiginit, METH_VARARGS, NULL},
	 { "new_FdmAmericanStepCondition", _wrap_new_FdmAmericanStepCondition, METH_VARARGS, NULL},
	 { "delete_FdmAmericanStepCondition", _wrap_delete_FdmAmericanStepCondition, METH_O, NULL},
	 { "FdmAmericanStepCondition_swigregister", FdmAmericanStepCondition_swigregister, METH_O, NULL},
	 { "FdmAmericanStepCondition_swiginit", FdmAmericanStepCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmArithmeticAverageCondition", _wrap_new_FdmArithmeticAverageCondition, METH_VARARGS, NULL},
	 { "delete_FdmArithmeticAverageCondition", _wrap_delete_FdmArithmeticAverageCondition, METH_O, NULL},
	 { "FdmArithmeticAverageCondition_swigregister", FdmArithmeticAverageCondition_swigregister, METH_O, NULL},
	 { "FdmArithmeticAverageCondition_swiginit", FdmArithmeticAverageCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBermudanStepCondition", _wrap_new_FdmBermudanStepCondition, METH_VARARGS, NULL},
	 { "FdmBermudanStepCondition_exerciseTimes", _wrap_FdmBermudanStepCondition_exerciseTimes, METH_O, NULL},
	 { "delete_FdmBermudanStepCondition", _wrap_delete_FdmBermudanStepCondition, METH_O, NULL},
	 { "FdmBermudanStepCondition_swigregister", FdmBermudanStepCondition_swigregister, METH_O, NULL},
	 { "FdmBermudanStepCondition_swiginit", FdmBermudanStepCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSimpleStorageCondition", _wrap_new_FdmSimpleStorageCondition, METH_VARARGS, NULL},
	 { "delete_FdmSimpleStorageCondition", _wrap_delete_FdmSimpleStorageCondition, METH_O, NULL},
	 { "FdmSimpleStorageCondition_swigregister", FdmSimpleStorageCondition_swigregister, METH_O, NULL},
	 { "FdmSimpleStorageCondition_swiginit", FdmSimpleStorageCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSimpleSwingCondition", _wrap_new_FdmSimpleSwingCondition, METH_VARARGS, NULL},
	 { "delete_FdmSimpleSwingCondition", _wrap_delete_FdmSimpleSwingCondition, METH_O, NULL},
	 { "FdmSimpleSwingCondition_swigregister", FdmSimpleSwingCondition_swigregister, METH_O, NULL},
	 { "FdmSimpleSwingCondition_swiginit", FdmSimpleSwingCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDividendHandler", _wrap_new_FdmDividendHandler, METH_VARARGS, NULL},
	 { "FdmDividendHandler_dividendTimes", _wrap_FdmDividendHandler_dividendTimes, METH_O, NULL},
	 { "FdmDividendHandler_dividendDates", _wrap_FdmDividendHandler_dividendDates, METH_O, NULL},
	 { "FdmDividendHandler_dividends", _wrap_FdmDividendHandler_dividends, METH_O, NULL},
	 { "delete_FdmDividendHandler", _wrap_delete_FdmDividendHandler, METH_O, NULL},
	 { "FdmDividendHandler_swigregister", FdmDividendHandler_swigregister, METH_O, NULL},
	 { "FdmDividendHandler_swiginit", FdmDividendHandler_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSolverDesc", _wrap_new_FdmSolverDesc, METH_VARARGS, NULL},
	 { "FdmSolverDesc_getMesher", _wrap_FdmSolverDesc_getMesher, METH_O, NULL},
	 { "FdmSolverDesc_getBcSet", _wrap_FdmSolverDesc_getBcSet, METH_O, NULL},
	 { "FdmSolverDesc_getStepConditions", _wrap_FdmSolverDesc_getStepConditions, METH_O, NULL},
	 { "FdmSolverDesc_getCalculator", _wrap_FdmSolverDesc_getCalculator, METH_O, NULL},
	 { "FdmSolverDesc_getMaturity", _wrap_FdmSolverDesc_getMaturity, METH_O, NULL},
	 { "FdmSolverDesc_getTimeSteps", _wrap_FdmSolverDesc_getTimeSteps, METH_O, NULL},
	 { "FdmSolverDesc_getDampingSteps", _wrap_FdmSolverDesc_getDampingSteps, METH_O, NULL},
	 { "delete_FdmSolverDesc", _wrap_delete_FdmSolverDesc, METH_O, NULL},
	 { "FdmSolverDesc_swigregister", FdmSolverDesc_swigregister, METH_O, NULL},
	 { "FdmSolverDesc_swiginit", FdmSolverDesc_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm1DimSolver", _wrap_new_Fdm1DimSolver, METH_VARARGS, NULL},
	 { "Fdm1DimSolver_interpolateAt", _wrap_Fdm1DimSolver_interpolateAt, METH_VARARGS, NULL},
	 { "Fdm1DimSolver_thetaAt", _wrap_Fdm1DimSolver_thetaAt, METH_VARARGS, NULL},
	 { "Fdm1DimSolver_derivativeX", _wrap_Fdm1DimSolver_derivativeX, METH_VARARGS, NULL},
	 { "Fdm1DimSolver_derivativeXX", _wrap_Fdm1DimSolver_derivativeXX, METH_VARARGS, NULL},
	 { "delete_Fdm1DimSolver", _wrap_delete_Fdm1DimSolver, METH_O, NULL},
	 { "Fdm1DimSolver_swigregister", Fdm1DimSolver_swigregister, METH_O, NULL},
	 { "Fdm1DimSolver_swiginit", Fdm1DimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBackwardSolver", _wrap_new_FdmBackwardSolver, METH_VARARGS, NULL},
	 { "FdmBackwardSolver_rollback", _wrap_FdmBackwardSolver_rollback, METH_VARARGS, NULL},
	 { "delete_FdmBackwardSolver", _wrap_delete_FdmBackwardSolver, METH_O, NULL},
	 { "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, NULL},
	 { "Fdm2dBlackScholesSolver_valueAt", _wrap_Fdm2dBlackScholesSolver_valueAt, METH_VARARGS, NULL},
	 { "Fdm2dBlackScholesSolver_thetaAt", _wrap_Fdm2dBlackScholesSolver_thetaAt, METH_VARARGS, NULL},
	 { "Fdm2dBlackScholesSolver_deltaXat", _wrap_Fdm2dBlackScholesSolver_deltaXat, METH_VARARGS, NULL},
	 { "Fdm2dBlackScholesSolver_deltaYat", _wrap_Fdm2dBlackScholesSolver_deltaYat, METH_VARARGS, NULL},
	 { "Fdm2dBlackScholesSolver_gammaXat", _wrap_Fdm2dBlackScholesSolver_gammaXat, METH_VARARGS, NULL},
	 { "Fdm2dBlackScholesSolver_gammaYat", _wrap_Fdm2dBlackScholesSolver_gammaYat, METH_VARARGS, NULL},
	 { "Fdm2dBlackScholesSolver_gammaXYat", _wrap_Fdm2dBlackScholesSolver_gammaXYat, METH_VARARGS, NULL},
	 { "delete_Fdm2dBlackScholesSolver", _wrap_delete_Fdm2dBlackScholesSolver, METH_O, NULL},
	 { "Fdm2dBlackScholesSolver_swigregister", Fdm2dBlackScholesSolver_swigregister, METH_O, NULL},
	 { "Fdm2dBlackScholesSolver_swiginit", Fdm2dBlackScholesSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm2DimSolver", _wrap_new_Fdm2DimSolver, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_interpolateAt", _wrap_Fdm2DimSolver_interpolateAt, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_thetaAt", _wrap_Fdm2DimSolver_thetaAt, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_derivativeX", _wrap_Fdm2DimSolver_derivativeX, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_derivativeY", _wrap_Fdm2DimSolver_derivativeY, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_derivativeXX", _wrap_Fdm2DimSolver_derivativeXX, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_derivativeYY", _wrap_Fdm2DimSolver_derivativeYY, METH_VARARGS, NULL},
	 { "Fdm2DimSolver_derivativeXY", _wrap_Fdm2DimSolver_derivativeXY, METH_VARARGS, NULL},
	 { "delete_Fdm2DimSolver", _wrap_delete_Fdm2DimSolver, METH_O, NULL},
	 { "Fdm2DimSolver_swigregister", Fdm2DimSolver_swigregister, METH_O, NULL},
	 { "Fdm2DimSolver_swiginit", Fdm2DimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm3DimSolver", _wrap_new_Fdm3DimSolver, METH_VARARGS, NULL},
	 { "Fdm3DimSolver_performCalculations", _wrap_Fdm3DimSolver_performCalculations, METH_O, NULL},
	 { "Fdm3DimSolver_interpolateAt", _wrap_Fdm3DimSolver_interpolateAt, METH_VARARGS, NULL},
	 { "Fdm3DimSolver_thetaAt", _wrap_Fdm3DimSolver_thetaAt, METH_VARARGS, NULL},
	 { "delete_Fdm3DimSolver", _wrap_delete_Fdm3DimSolver, METH_O, NULL},
	 { "Fdm3DimSolver_swigregister", Fdm3DimSolver_swigregister, METH_O, NULL},
	 { "Fdm3DimSolver_swiginit", Fdm3DimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmG2Solver", _wrap_new_FdmG2Solver, METH_VARARGS, NULL},
	 { "FdmG2Solver_valueAt", _wrap_FdmG2Solver_valueAt, METH_VARARGS, NULL},
	 { "delete_FdmG2Solver", _wrap_delete_FdmG2Solver, METH_O, NULL},
	 { "FdmG2Solver_swigregister", FdmG2Solver_swigregister, METH_O, NULL},
	 { "FdmG2Solver_swiginit", FdmG2Solver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonHullWhiteSolver", _wrap_new_FdmHestonHullWhiteSolver, METH_VARARGS, NULL},
	 { "FdmHestonHullWhiteSolver_valueAt", _wrap_FdmHestonHullWhiteSolver_valueAt, METH_VARARGS, NULL},
	 { "FdmHestonHullWhiteSolver_thetaAt", _wrap_FdmHestonHullWhiteSolver_thetaAt, METH_VARARGS, NULL},
	 { "FdmHestonHullWhiteSolver_deltaAt", _wrap_FdmHestonHullWhiteSolver_deltaAt, METH_VARARGS, NULL},
	 { "FdmHestonHullWhiteSolver_gammaAt", _wrap_FdmHestonHullWhiteSolver_gammaAt, METH_VARARGS, NULL},
	 { "delete_FdmHestonHullWhiteSolver", _wrap_delete_FdmHestonHullWhiteSolver, METH_O, NULL},
	 { "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, NULL},
	 { "FdmHestonSolver_valueAt", _wrap_FdmHestonSolver_valueAt, METH_VARARGS, NULL},
	 { "FdmHestonSolver_thetaAt", _wrap_FdmHestonSolver_thetaAt, METH_VARARGS, NULL},
	 { "FdmHestonSolver_deltaAt", _wrap_FdmHestonSolver_deltaAt, METH_VARARGS, NULL},
	 { "FdmHestonSolver_gammaAt", _wrap_FdmHestonSolver_gammaAt, METH_VARARGS, NULL},
	 { "FdmHestonSolver_meanVarianceDeltaAt", _wrap_FdmHestonSolver_meanVarianceDeltaAt, METH_VARARGS, NULL},
	 { "FdmHestonSolver_meanVarianceGammaAt", _wrap_FdmHestonSolver_meanVarianceGammaAt, METH_VARARGS, NULL},
	 { "delete_FdmHestonSolver", _wrap_delete_FdmHestonSolver, METH_O, NULL},
	 { "FdmHestonSolver_swigregister", FdmHestonSolver_swigregister, METH_O, NULL},
	 { "FdmHestonSolver_swiginit", FdmHestonSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHullWhiteSolver", _wrap_new_FdmHullWhiteSolver, METH_VARARGS, NULL},
	 { "FdmHullWhiteSolver_valueAt", _wrap_FdmHullWhiteSolver_valueAt, METH_VARARGS, NULL},
	 { "delete_FdmHullWhiteSolver", _wrap_delete_FdmHullWhiteSolver, METH_O, NULL},
	 { "FdmHullWhiteSolver_swigregister", FdmHullWhiteSolver_swigregister, METH_O, NULL},
	 { "FdmHullWhiteSolver_swiginit", FdmHullWhiteSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm4dimSolver", _wrap_new_Fdm4dimSolver, METH_VARARGS, NULL},
	 { "Fdm4dimSolver_interpolateAt", _wrap_Fdm4dimSolver_interpolateAt, METH_VARARGS, NULL},
	 { "Fdm4dimSolver_thetaAt", _wrap_Fdm4dimSolver_thetaAt, METH_VARARGS, NULL},
	 { "delete_Fdm4dimSolver", _wrap_delete_Fdm4dimSolver, METH_O, NULL},
	 { "Fdm4dimSolver_swigregister", Fdm4dimSolver_swigregister, METH_O, NULL},
	 { "Fdm4dimSolver_swiginit", Fdm4dimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm5dimSolver", _wrap_new_Fdm5dimSolver, METH_VARARGS, NULL},
	 { "Fdm5dimSolver_interpolateAt", _wrap_Fdm5dimSolver_interpolateAt, METH_VARARGS, NULL},
	 { "Fdm5dimSolver_thetaAt", _wrap_Fdm5dimSolver_thetaAt, METH_VARARGS, NULL},
	 { "delete_Fdm5dimSolver", _wrap_delete_Fdm5dimSolver, METH_O, NULL},
	 { "Fdm5dimSolver_swigregister", Fdm5dimSolver_swigregister, METH_O, NULL},
	 { "Fdm5dimSolver_swiginit", Fdm5dimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm6dimSolver", _wrap_new_Fdm6dimSolver, METH_VARARGS, NULL},
	 { "Fdm6dimSolver_interpolateAt", _wrap_Fdm6dimSolver_interpolateAt, METH_VARARGS, NULL},
	 { "Fdm6dimSolver_thetaAt", _wrap_Fdm6dimSolver_thetaAt, METH_VARARGS, NULL},
	 { "delete_Fdm6dimSolver", _wrap_delete_Fdm6dimSolver, METH_O, NULL},
	 { "Fdm6dimSolver_swigregister", Fdm6dimSolver_swigregister, METH_O, NULL},
	 { "Fdm6dimSolver_swiginit", Fdm6dimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmIndicesOnBoundary", _wrap_new_FdmIndicesOnBoundary, METH_VARARGS, NULL},
	 { "FdmIndicesOnBoundary_getIndices", _wrap_FdmIndicesOnBoundary_getIndices, METH_O, NULL},
	 { "delete_FdmIndicesOnBoundary", _wrap_delete_FdmIndicesOnBoundary, METH_O, NULL},
	 { "FdmIndicesOnBoundary_swigregister", FdmIndicesOnBoundary_swigregister, METH_O, NULL},
	 { "FdmIndicesOnBoundary_swiginit", FdmIndicesOnBoundary_swiginit, METH_VARARGS, NULL},
	 { "RiskNeutralDensityCalculator_pdf", _wrap_RiskNeutralDensityCalculator_pdf, METH_VARARGS, NULL},
	 { "RiskNeutralDensityCalculator_cdf", _wrap_RiskNeutralDensityCalculator_cdf, METH_VARARGS, NULL},
	 { "RiskNeutralDensityCalculator_invcdf", _wrap_RiskNeutralDensityCalculator_invcdf, METH_VARARGS, NULL},
	 { "delete_RiskNeutralDensityCalculator", _wrap_delete_RiskNeutralDensityCalculator, METH_O, NULL},
	 { "RiskNeutralDensityCalculator_swigregister", RiskNeutralDensityCalculator_swigregister, METH_O, NULL},
	 { "new_BSMRNDCalculator", _wrap_new_BSMRNDCalculator, METH_O, NULL},
	 { "delete_BSMRNDCalculator", _wrap_delete_BSMRNDCalculator, METH_O, NULL},
	 { "BSMRNDCalculator_swigregister", BSMRNDCalculator_swigregister, METH_O, NULL},
	 { "BSMRNDCalculator_swiginit", BSMRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_CEVRNDCalculator", _wrap_new_CEVRNDCalculator, METH_VARARGS, NULL},
	 { "CEVRNDCalculator_massAtZero", _wrap_CEVRNDCalculator_massAtZero, METH_VARARGS, NULL},
	 { "delete_CEVRNDCalculator", _wrap_delete_CEVRNDCalculator, METH_O, NULL},
	 { "CEVRNDCalculator_swigregister", CEVRNDCalculator_swigregister, METH_O, NULL},
	 { "CEVRNDCalculator_swiginit", CEVRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_GBSMRNDCalculator", _wrap_new_GBSMRNDCalculator, METH_O, NULL},
	 { "delete_GBSMRNDCalculator", _wrap_delete_GBSMRNDCalculator, METH_O, NULL},
	 { "GBSMRNDCalculator_swigregister", GBSMRNDCalculator_swigregister, METH_O, NULL},
	 { "GBSMRNDCalculator_swiginit", GBSMRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_HestonRNDCalculator", _wrap_new_HestonRNDCalculator, METH_VARARGS, NULL},
	 { "delete_HestonRNDCalculator", _wrap_delete_HestonRNDCalculator, METH_O, NULL},
	 { "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, NULL},
	 { "LocalVolRNDCalculator_mesher", _wrap_LocalVolRNDCalculator_mesher, METH_VARARGS, NULL},
	 { "LocalVolRNDCalculator_rescaleTimeSteps", _wrap_LocalVolRNDCalculator_rescaleTimeSteps, METH_O, NULL},
	 { "delete_LocalVolRNDCalculator", _wrap_delete_LocalVolRNDCalculator, METH_O, NULL},
	 { "LocalVolRNDCalculator_swigregister", LocalVolRNDCalculator_swigregister, METH_O, NULL},
	 { "LocalVolRNDCalculator_swiginit", LocalVolRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_SquareRootProcessRNDCalculator", _wrap_new_SquareRootProcessRNDCalculator, METH_VARARGS, NULL},
	 { "SquareRootProcessRNDCalculator_stationary_pdf", _wrap_SquareRootProcessRNDCalculator_stationary_pdf, METH_VARARGS, NULL},
	 { "SquareRootProcessRNDCalculator_stationary_cdf", _wrap_SquareRootProcessRNDCalculator_stationary_cdf, METH_VARARGS, NULL},
	 { "SquareRootProcessRNDCalculator_stationary_invcdf", _wrap_SquareRootProcessRNDCalculator_stationary_invcdf, METH_VARARGS, NULL},
	 { "delete_SquareRootProcessRNDCalculator", _wrap_delete_SquareRootProcessRNDCalculator, METH_O, NULL},
	 { "SquareRootProcessRNDCalculator_swigregister", SquareRootProcessRNDCalculator_swigregister, METH_O, NULL},
	 { "SquareRootProcessRNDCalculator_swiginit", SquareRootProcessRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "delete_FittingMethod", _wrap_delete_FittingMethod, METH_O, NULL},
	 { "FittingMethod_size", _wrap_FittingMethod_size, METH_O, NULL},
	 { "FittingMethod_solution", _wrap_FittingMethod_solution, METH_O, NULL},
	 { "FittingMethod_numberOfIterations", _wrap_FittingMethod_numberOfIterations, METH_O, NULL},
	 { "FittingMethod_minimumCostValue", _wrap_FittingMethod_minimumCostValue, METH_O, NULL},
	 { "FittingMethod_constrainAtZero", _wrap_FittingMethod_constrainAtZero, METH_O, NULL},
	 { "FittingMethod_weights", _wrap_FittingMethod_weights, METH_O, NULL},
	 { "FittingMethod_swigregister", FittingMethod_swigregister, METH_O, NULL},
	 { "new_FittedBondDiscountCurve", _wrap_new_FittedBondDiscountCurve, METH_VARARGS, NULL},
	 { "FittedBondDiscountCurve_fitResults", _wrap_FittedBondDiscountCurve_fitResults, METH_O, NULL},
	 { "delete_FittedBondDiscountCurve", _wrap_delete_FittedBondDiscountCurve, METH_O, NULL},
	 { "FittedBondDiscountCurve_swigregister", FittedBondDiscountCurve_swigregister, METH_O, NULL},
	 { "FittedBondDiscountCurve_swiginit", FittedBondDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_ExponentialSplinesFitting", _wrap_new_ExponentialSplinesFitting, METH_VARARGS, NULL},
	 { "delete_ExponentialSplinesFitting", _wrap_delete_ExponentialSplinesFitting, METH_O, NULL},
	 { "ExponentialSplinesFitting_swigregister", ExponentialSplinesFitting_swigregister, METH_O, NULL},
	 { "ExponentialSplinesFitting_swiginit", ExponentialSplinesFitting_swiginit, METH_VARARGS, NULL},
	 { "new_NelsonSiegelFitting", _wrap_new_NelsonSiegelFitting, METH_VARARGS, NULL},
	 { "delete_NelsonSiegelFitting", _wrap_delete_NelsonSiegelFitting, METH_O, NULL},
	 { "NelsonSiegelFitting_swigregister", NelsonSiegelFitting_swigregister, METH_O, NULL},
	 { "NelsonSiegelFitting_swiginit", NelsonSiegelFitting_swiginit, METH_VARARGS, NULL},
	 { "new_SvenssonFitting", _wrap_new_SvenssonFitting, METH_VARARGS, NULL},
	 { "delete_SvenssonFitting", _wrap_delete_SvenssonFitting, METH_O, NULL},
	 { "SvenssonFitting_swigregister", SvenssonFitting_swigregister, METH_O, NULL},
	 { "SvenssonFitting_swiginit", SvenssonFitting_swiginit, METH_VARARGS, NULL},
	 { "new_CubicBSplinesFitting", _wrap_new_CubicBSplinesFitting, METH_VARARGS, NULL},
	 { "CubicBSplinesFitting_basisFunction", _wrap_CubicBSplinesFitting_basisFunction, METH_VARARGS, NULL},
	 { "delete_CubicBSplinesFitting", _wrap_delete_CubicBSplinesFitting, METH_O, NULL},
	 { "CubicBSplinesFitting_swigregister", CubicBSplinesFitting_swigregister, METH_O, NULL},
	 { "CubicBSplinesFitting_swiginit", CubicBSplinesFitting_swiginit, METH_VARARGS, NULL},
	 { "new_SimplePolynomialFitting", _wrap_new_SimplePolynomialFitting, METH_VARARGS, NULL},
	 { "delete_SimplePolynomialFitting", _wrap_delete_SimplePolynomialFitting, METH_O, NULL},
	 { "SimplePolynomialFitting_swigregister", SimplePolynomialFitting_swigregister, METH_O, NULL},
	 { "SimplePolynomialFitting_swiginit", SimplePolynomialFitting_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardCurve", _wrap_new_ForwardCurve, METH_VARARGS, NULL},
	 { "ForwardCurve_dates", _wrap_ForwardCurve_dates, METH_O, NULL},
	 { "ForwardCurve_forwards", _wrap_ForwardCurve_forwards, METH_O, NULL},
	 { "ForwardCurve_nodes", _wrap_ForwardCurve_nodes, METH_O, NULL},
	 { "delete_ForwardCurve", _wrap_delete_ForwardCurve, METH_O, NULL},
	 { "ForwardCurve_swigregister", ForwardCurve_swigregister, METH_O, NULL},
	 { "ForwardCurve_swiginit", ForwardCurve_swiginit, METH_VARARGS, NULL},
	 { "Forward_settlementDate", _wrap_Forward_settlementDate, METH_O, NULL},
	 { "Forward_isExpired", _wrap_Forward_isExpired, METH_O, NULL},
	 { "Forward_calendar", _wrap_Forward_calendar, METH_O, NULL},
	 { "Forward_businessDayConvention", _wrap_Forward_businessDayConvention, METH_O, NULL},
	 { "Forward_dayCounter", _wrap_Forward_dayCounter, METH_O, NULL},
	 { "Forward_discountCurve", _wrap_Forward_discountCurve, METH_O, NULL},
	 { "Forward_incomeDiscountCurve", _wrap_Forward_incomeDiscountCurve, METH_O, NULL},
	 { "Forward_spotValue", _wrap_Forward_spotValue, METH_O, NULL},
	 { "Forward_spotIncome", _wrap_Forward_spotIncome, METH_VARARGS, NULL},
	 { "Forward_forwardValue", _wrap_Forward_forwardValue, METH_O, NULL},
	 { "Forward_impliedYield", _wrap_Forward_impliedYield, METH_VARARGS, NULL},
	 { "delete_Forward", _wrap_delete_Forward, METH_O, NULL},
	 { "Forward_swigregister", Forward_swigregister, METH_O, NULL},
	 { "new_FixedRateBondForward", _wrap_new_FixedRateBondForward, METH_VARARGS, NULL},
	 { "FixedRateBondForward_forwardPrice", _wrap_FixedRateBondForward_forwardPrice, METH_O, NULL},
	 { "FixedRateBondForward_cleanForwardPrice", _wrap_FixedRateBondForward_cleanForwardPrice, METH_O, NULL},
	 { "delete_FixedRateBondForward", _wrap_delete_FixedRateBondForward, METH_O, NULL},
	 { "FixedRateBondForward_swigregister", FixedRateBondForward_swigregister, METH_O, NULL},
	 { "FixedRateBondForward_swiginit", FixedRateBondForward_swiginit, METH_VARARGS, NULL},
	 { "new_Position", _wrap_new_Position, METH_NOARGS, NULL},
	 { "delete_Position", _wrap_delete_Position, METH_O, NULL},
	 { "Position_swigregister", Position_swigregister, METH_O, NULL},
	 { "Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardRateAgreement", _wrap_new_ForwardRateAgreement, METH_VARARGS, NULL},
	 { "ForwardRateAgreement_fixingDate", _wrap_ForwardRateAgreement_fixingDate, METH_O, NULL},
	 { "ForwardRateAgreement_spotIncome", _wrap_ForwardRateAgreement_spotIncome, METH_VARARGS, NULL},
	 { "ForwardRateAgreement_spotValue", _wrap_ForwardRateAgreement_spotValue, METH_O, NULL},
	 { "ForwardRateAgreement_forwardRate", _wrap_ForwardRateAgreement_forwardRate, METH_O, NULL},
	 { "delete_ForwardRateAgreement", _wrap_delete_ForwardRateAgreement, METH_O, NULL},
	 { "ForwardRateAgreement_swigregister", ForwardRateAgreement_swigregister, METH_O, NULL},
	 { "ForwardRateAgreement_swiginit", ForwardRateAgreement_swiginit, METH_VARARGS, NULL},
	 { "Gaussian1dModel_stateProcess", _wrap_Gaussian1dModel_stateProcess, METH_O, NULL},
	 { "Gaussian1dModel_numeraire", _wrap_Gaussian1dModel_numeraire, METH_VARARGS, NULL},
	 { "Gaussian1dModel_zerobond", _wrap_Gaussian1dModel_zerobond, METH_VARARGS, NULL},
	 { "Gaussian1dModel_zerobondOption", _wrap_Gaussian1dModel_zerobondOption, METH_VARARGS, NULL},
	 { "Gaussian1dModel_forwardRate", _wrap_Gaussian1dModel_forwardRate, METH_VARARGS, NULL},
	 { "Gaussian1dModel_swapRate", _wrap_Gaussian1dModel_swapRate, METH_VARARGS, NULL},
	 { "Gaussian1dModel_swapAnnuity", _wrap_Gaussian1dModel_swapAnnuity, METH_VARARGS, NULL},
	 { "delete_Gaussian1dModel", _wrap_delete_Gaussian1dModel, METH_O, NULL},
	 { "Gaussian1dModel_swigregister", Gaussian1dModel_swigregister, METH_O, NULL},
	 { "new_Gsr", _wrap_new_Gsr, METH_VARARGS, NULL},
	 { "Gsr_calibrateVolatilitiesIterative", _wrap_Gsr_calibrateVolatilitiesIterative, METH_VARARGS, NULL},
	 { "Gsr_reversion", _wrap_Gsr_reversion, METH_O, NULL},
	 { "Gsr_volatility", _wrap_Gsr_volatility, METH_O, NULL},
	 { "Gsr_params", _wrap_Gsr_params, METH_O, NULL},
	 { "Gsr_calibrate", _wrap_Gsr_calibrate, METH_VARARGS, NULL},
	 { "Gsr_setParams", _wrap_Gsr_setParams, METH_VARARGS, NULL},
	 { "Gsr_value", _wrap_Gsr_value, METH_VARARGS, NULL},
	 { "Gsr_constraint", _wrap_Gsr_constraint, METH_O, NULL},
	 { "Gsr_endCriteria", _wrap_Gsr_endCriteria, METH_O, NULL},
	 { "Gsr_problemValues", _wrap_Gsr_problemValues, METH_O, NULL},
	 { "Gsr_functionEvaluation", _wrap_Gsr_functionEvaluation, METH_O, NULL},
	 { "delete_Gsr", _wrap_delete_Gsr, METH_O, NULL},
	 { "Gsr_swigregister", Gsr_swigregister, METH_O, NULL},
	 { "Gsr_swiginit", Gsr_swiginit, METH_VARARGS, NULL},
	 { "new_MarkovFunctional", _wrap_new_MarkovFunctional, METH_VARARGS, NULL},
	 { "MarkovFunctional_volatility", _wrap_MarkovFunctional_volatility, METH_O, NULL},
	 { "MarkovFunctional_calibrate", _wrap_MarkovFunctional_calibrate, METH_VARARGS, NULL},
	 { "MarkovFunctional_params", _wrap_MarkovFunctional_params, METH_O, NULL},
	 { "MarkovFunctional_setParams", _wrap_MarkovFunctional_setParams, METH_VARARGS, NULL},
	 { "MarkovFunctional_value", _wrap_MarkovFunctional_value, METH_VARARGS, NULL},
	 { "MarkovFunctional_constraint", _wrap_MarkovFunctional_constraint, METH_O, NULL},
	 { "MarkovFunctional_endCriteria", _wrap_MarkovFunctional_endCriteria, METH_O, NULL},
	 { "MarkovFunctional_problemValues", _wrap_MarkovFunctional_problemValues, METH_O, NULL},
	 { "MarkovFunctional_functionEvaluation", _wrap_MarkovFunctional_functionEvaluation, METH_O, NULL},
	 { "delete_MarkovFunctional", _wrap_delete_MarkovFunctional, METH_O, NULL},
	 { "MarkovFunctional_swigregister", MarkovFunctional_swigregister, METH_O, NULL},
	 { "MarkovFunctional_swiginit", MarkovFunctional_swiginit, METH_VARARGS, NULL},
	 { "new_MarkovFunctionalSettings", _wrap_new_MarkovFunctionalSettings, METH_VARARGS, NULL},
	 { "MarkovFunctionalSettings_validate", _wrap_MarkovFunctionalSettings_validate, METH_O, NULL},
	 { "delete_MarkovFunctionalSettings", _wrap_delete_MarkovFunctionalSettings, METH_O, NULL},
	 { "MarkovFunctionalSettings_swigregister", MarkovFunctionalSettings_swigregister, METH_O, NULL},
	 { "MarkovFunctionalSettings_swiginit", MarkovFunctionalSettings_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dSwaptionEngine", _wrap_new_Gaussian1dSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_Gaussian1dSwaptionEngine", _wrap_delete_Gaussian1dSwaptionEngine, METH_O, NULL},
	 { "Gaussian1dSwaptionEngine_swigregister", Gaussian1dSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dSwaptionEngine_swiginit", Gaussian1dSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dJamshidianSwaptionEngine", _wrap_new_Gaussian1dJamshidianSwaptionEngine, METH_O, NULL},
	 { "delete_Gaussian1dJamshidianSwaptionEngine", _wrap_delete_Gaussian1dJamshidianSwaptionEngine, METH_O, NULL},
	 { "Gaussian1dJamshidianSwaptionEngine_swigregister", Gaussian1dJamshidianSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dJamshidianSwaptionEngine_swiginit", Gaussian1dJamshidianSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dNonstandardSwaptionEngine", _wrap_new_Gaussian1dNonstandardSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_Gaussian1dNonstandardSwaptionEngine", _wrap_delete_Gaussian1dNonstandardSwaptionEngine, METH_O, NULL},
	 { "Gaussian1dNonstandardSwaptionEngine_swigregister", Gaussian1dNonstandardSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dNonstandardSwaptionEngine_swiginit", Gaussian1dNonstandardSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dFloatFloatSwaptionEngine", _wrap_new_Gaussian1dFloatFloatSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_Gaussian1dFloatFloatSwaptionEngine", _wrap_delete_Gaussian1dFloatFloatSwaptionEngine, METH_O, NULL},
	 { "Gaussian1dFloatFloatSwaptionEngine_swigregister", Gaussian1dFloatFloatSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dFloatFloatSwaptionEngine_swiginit", Gaussian1dFloatFloatSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SegmentIntegral", _wrap_new_SegmentIntegral, METH_O, NULL},
	 { "SegmentIntegral___call__", _wrap_SegmentIntegral___call__, METH_VARARGS, NULL},
	 { "delete_SegmentIntegral", _wrap_delete_SegmentIntegral, METH_O, NULL},
	 { "SegmentIntegral_swigregister", SegmentIntegral_swigregister, METH_O, NULL},
	 { "SegmentIntegral_swiginit", SegmentIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_TrapezoidIntegralDefault", _wrap_new_TrapezoidIntegralDefault, METH_VARARGS, NULL},
	 { "TrapezoidIntegralDefault___call__", _wrap_TrapezoidIntegralDefault___call__, METH_VARARGS, NULL},
	 { "delete_TrapezoidIntegralDefault", _wrap_delete_TrapezoidIntegralDefault, METH_O, NULL},
	 { "TrapezoidIntegralDefault_swigregister", TrapezoidIntegralDefault_swigregister, METH_O, NULL},
	 { "TrapezoidIntegralDefault_swiginit", TrapezoidIntegralDefault_swiginit, METH_VARARGS, NULL},
	 { "new_TrapezoidIntegralMidPoint", _wrap_new_TrapezoidIntegralMidPoint, METH_VARARGS, NULL},
	 { "TrapezoidIntegralMidPoint___call__", _wrap_TrapezoidIntegralMidPoint___call__, METH_VARARGS, NULL},
	 { "delete_TrapezoidIntegralMidPoint", _wrap_delete_TrapezoidIntegralMidPoint, METH_O, NULL},
	 { "TrapezoidIntegralMidPoint_swigregister", TrapezoidIntegralMidPoint_swigregister, METH_O, NULL},
	 { "TrapezoidIntegralMidPoint_swiginit", TrapezoidIntegralMidPoint_swiginit, METH_VARARGS, NULL},
	 { "new_SimpsonIntegral", _wrap_new_SimpsonIntegral, METH_VARARGS, NULL},
	 { "SimpsonIntegral___call__", _wrap_SimpsonIntegral___call__, METH_VARARGS, NULL},
	 { "delete_SimpsonIntegral", _wrap_delete_SimpsonIntegral, METH_O, NULL},
	 { "SimpsonIntegral_swigregister", SimpsonIntegral_swigregister, METH_O, NULL},
	 { "SimpsonIntegral_swiginit", SimpsonIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_GaussKronrodAdaptive", _wrap_new_GaussKronrodAdaptive, METH_VARARGS, NULL},
	 { "GaussKronrodAdaptive___call__", _wrap_GaussKronrodAdaptive___call__, METH_VARARGS, NULL},
	 { "delete_GaussKronrodAdaptive", _wrap_delete_GaussKronrodAdaptive, METH_O, NULL},
	 { "GaussKronrodAdaptive_swigregister", GaussKronrodAdaptive_swigregister, METH_O, NULL},
	 { "GaussKronrodAdaptive_swiginit", GaussKronrodAdaptive_swiginit, METH_VARARGS, NULL},
	 { "new_GaussKronrodNonAdaptive", _wrap_new_GaussKronrodNonAdaptive, METH_VARARGS, NULL},
	 { "GaussKronrodNonAdaptive___call__", _wrap_GaussKronrodNonAdaptive___call__, METH_VARARGS, NULL},
	 { "delete_GaussKronrodNonAdaptive", _wrap_delete_GaussKronrodNonAdaptive, METH_O, NULL},
	 { "GaussKronrodNonAdaptive_swigregister", GaussKronrodNonAdaptive_swigregister, METH_O, NULL},
	 { "GaussKronrodNonAdaptive_swiginit", GaussKronrodNonAdaptive_swiginit, METH_VARARGS, NULL},
	 { "new_GaussLobattoIntegral", _wrap_new_GaussLobattoIntegral, METH_VARARGS, NULL},
	 { "GaussLobattoIntegral___call__", _wrap_GaussLobattoIntegral___call__, METH_VARARGS, NULL},
	 { "delete_GaussLobattoIntegral", _wrap_delete_GaussLobattoIntegral, METH_O, NULL},
	 { "GaussLobattoIntegral_swigregister", GaussLobattoIntegral_swigregister, METH_O, NULL},
	 { "GaussLobattoIntegral_swiginit", GaussLobattoIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_GaussLaguerreIntegration", _wrap_new_GaussLaguerreIntegration, METH_VARARGS, NULL},
	 { "GaussLaguerreIntegration___call__", _wrap_GaussLaguerreIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussLaguerreIntegration", _wrap_delete_GaussLaguerreIntegration, METH_O, NULL},
	 { "GaussLaguerreIntegration_swigregister", GaussLaguerreIntegration_swigregister, METH_O, NULL},
	 { "GaussLaguerreIntegration_swiginit", GaussLaguerreIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussHermiteIntegration", _wrap_new_GaussHermiteIntegration, METH_VARARGS, NULL},
	 { "GaussHermiteIntegration___call__", _wrap_GaussHermiteIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussHermiteIntegration", _wrap_delete_GaussHermiteIntegration, METH_O, NULL},
	 { "GaussHermiteIntegration_swigregister", GaussHermiteIntegration_swigregister, METH_O, NULL},
	 { "GaussHermiteIntegration_swiginit", GaussHermiteIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussJacobiIntegration", _wrap_new_GaussJacobiIntegration, METH_VARARGS, NULL},
	 { "GaussJacobiIntegration___call__", _wrap_GaussJacobiIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussJacobiIntegration", _wrap_delete_GaussJacobiIntegration, METH_O, NULL},
	 { "GaussJacobiIntegration_swigregister", GaussJacobiIntegration_swigregister, METH_O, NULL},
	 { "GaussJacobiIntegration_swiginit", GaussJacobiIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussHyperbolicIntegration", _wrap_new_GaussHyperbolicIntegration, METH_O, NULL},
	 { "GaussHyperbolicIntegration___call__", _wrap_GaussHyperbolicIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussHyperbolicIntegration", _wrap_delete_GaussHyperbolicIntegration, METH_O, NULL},
	 { "GaussHyperbolicIntegration_swigregister", GaussHyperbolicIntegration_swigregister, METH_O, NULL},
	 { "GaussHyperbolicIntegration_swiginit", GaussHyperbolicIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussLegendreIntegration", _wrap_new_GaussLegendreIntegration, METH_O, NULL},
	 { "GaussLegendreIntegration___call__", _wrap_GaussLegendreIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussLegendreIntegration", _wrap_delete_GaussLegendreIntegration, METH_O, NULL},
	 { "GaussLegendreIntegration_swigregister", GaussLegendreIntegration_swigregister, METH_O, NULL},
	 { "GaussLegendreIntegration_swiginit", GaussLegendreIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussChebyshevIntegration", _wrap_new_GaussChebyshevIntegration, METH_O, NULL},
	 { "GaussChebyshevIntegration___call__", _wrap_GaussChebyshevIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussChebyshevIntegration", _wrap_delete_GaussChebyshevIntegration, METH_O, NULL},
	 { "GaussChebyshevIntegration_swigregister", GaussChebyshevIntegration_swigregister, METH_O, NULL},
	 { "GaussChebyshevIntegration_swiginit", GaussChebyshevIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussChebyshev2ndIntegration", _wrap_new_GaussChebyshev2ndIntegration, METH_O, NULL},
	 { "GaussChebyshev2ndIntegration___call__", _wrap_GaussChebyshev2ndIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussChebyshev2ndIntegration", _wrap_delete_GaussChebyshev2ndIntegration, METH_O, NULL},
	 { "GaussChebyshev2ndIntegration_swigregister", GaussChebyshev2ndIntegration_swigregister, METH_O, NULL},
	 { "GaussChebyshev2ndIntegration_swiginit", GaussChebyshev2ndIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussGegenbauerIntegration", _wrap_new_GaussGegenbauerIntegration, METH_VARARGS, NULL},
	 { "GaussGegenbauerIntegration___call__", _wrap_GaussGegenbauerIntegration___call__, METH_VARARGS, NULL},
	 { "delete_GaussGegenbauerIntegration", _wrap_delete_GaussGegenbauerIntegration, METH_O, NULL},
	 { "GaussGegenbauerIntegration_swigregister", GaussGegenbauerIntegration_swigregister, METH_O, NULL},
	 { "GaussGegenbauerIntegration_swiginit", GaussGegenbauerIntegration_swiginit, METH_VARARGS, NULL},
	 { "SampleNumber_value", _wrap_SampleNumber_value, METH_O, NULL},
	 { "SampleNumber_weight", _wrap_SampleNumber_weight, METH_O, NULL},
	 { "delete_SampleNumber", _wrap_delete_SampleNumber, METH_O, NULL},
	 { "SampleNumber_swigregister", SampleNumber_swigregister, METH_O, NULL},
	 { "SampleArray_value", _wrap_SampleArray_value, METH_O, NULL},
	 { "SampleArray_weight", _wrap_SampleArray_weight, METH_O, NULL},
	 { "delete_SampleArray", _wrap_delete_SampleArray, METH_O, NULL},
	 { "SampleArray_swigregister", SampleArray_swigregister, METH_O, NULL},
	 { "SampleRealVector_value", _wrap_SampleRealVector_value, METH_O, NULL},
	 { "SampleRealVector_weight", _wrap_SampleRealVector_weight, METH_O, NULL},
	 { "delete_SampleRealVector", _wrap_delete_SampleRealVector, METH_O, NULL},
	 { "SampleRealVector_swigregister", SampleRealVector_swigregister, METH_O, NULL},
	 { "new_LecuyerUniformRng", _wrap_new_LecuyerUniformRng, METH_VARARGS, NULL},
	 { "LecuyerUniformRng_next", _wrap_LecuyerUniformRng_next, METH_O, NULL},
	 { "delete_LecuyerUniformRng", _wrap_delete_LecuyerUniformRng, METH_O, NULL},
	 { "LecuyerUniformRng_swigregister", LecuyerUniformRng_swigregister, METH_O, NULL},
	 { "LecuyerUniformRng_swiginit", LecuyerUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_KnuthUniformRng", _wrap_new_KnuthUniformRng, METH_VARARGS, NULL},
	 { "KnuthUniformRng_next", _wrap_KnuthUniformRng_next, METH_O, NULL},
	 { "delete_KnuthUniformRng", _wrap_delete_KnuthUniformRng, METH_O, NULL},
	 { "KnuthUniformRng_swigregister", KnuthUniformRng_swigregister, METH_O, NULL},
	 { "KnuthUniformRng_swiginit", KnuthUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_MersenneTwisterUniformRng", _wrap_new_MersenneTwisterUniformRng, METH_VARARGS, NULL},
	 { "MersenneTwisterUniformRng_next", _wrap_MersenneTwisterUniformRng_next, METH_O, NULL},
	 { "delete_MersenneTwisterUniformRng", _wrap_delete_MersenneTwisterUniformRng, METH_O, NULL},
	 { "MersenneTwisterUniformRng_swigregister", MersenneTwisterUniformRng_swigregister, METH_O, NULL},
	 { "MersenneTwisterUniformRng_swiginit", MersenneTwisterUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_UniformRandomGenerator", _wrap_new_UniformRandomGenerator, METH_VARARGS, NULL},
	 { "UniformRandomGenerator_next", _wrap_UniformRandomGenerator_next, METH_O, NULL},
	 { "UniformRandomGenerator_nextValue", _wrap_UniformRandomGenerator_nextValue, METH_O, NULL},
	 { "delete_UniformRandomGenerator", _wrap_delete_UniformRandomGenerator, METH_O, NULL},
	 { "UniformRandomGenerator_swigregister", UniformRandomGenerator_swigregister, METH_O, NULL},
	 { "UniformRandomGenerator_swiginit", UniformRandomGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitLecuyerGaussianRng", _wrap_new_CentralLimitLecuyerGaussianRng, METH_O, NULL},
	 { "CentralLimitLecuyerGaussianRng_next", _wrap_CentralLimitLecuyerGaussianRng_next, METH_O, NULL},
	 { "delete_CentralLimitLecuyerGaussianRng", _wrap_delete_CentralLimitLecuyerGaussianRng, METH_O, NULL},
	 { "CentralLimitLecuyerGaussianRng_swigregister", CentralLimitLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitLecuyerGaussianRng_swiginit", CentralLimitLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitKnuthGaussianRng", _wrap_new_CentralLimitKnuthGaussianRng, METH_O, NULL},
	 { "CentralLimitKnuthGaussianRng_next", _wrap_CentralLimitKnuthGaussianRng_next, METH_O, NULL},
	 { "delete_CentralLimitKnuthGaussianRng", _wrap_delete_CentralLimitKnuthGaussianRng, METH_O, NULL},
	 { "CentralLimitKnuthGaussianRng_swigregister", CentralLimitKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitKnuthGaussianRng_swiginit", CentralLimitKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitMersenneTwisterGaussianRng", _wrap_new_CentralLimitMersenneTwisterGaussianRng, METH_O, NULL},
	 { "CentralLimitMersenneTwisterGaussianRng_next", _wrap_CentralLimitMersenneTwisterGaussianRng_next, METH_O, NULL},
	 { "delete_CentralLimitMersenneTwisterGaussianRng", _wrap_delete_CentralLimitMersenneTwisterGaussianRng, METH_O, NULL},
	 { "CentralLimitMersenneTwisterGaussianRng_swigregister", CentralLimitMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitMersenneTwisterGaussianRng_swiginit", CentralLimitMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerLecuyerGaussianRng", _wrap_new_BoxMullerLecuyerGaussianRng, METH_O, NULL},
	 { "BoxMullerLecuyerGaussianRng_next", _wrap_BoxMullerLecuyerGaussianRng_next, METH_O, NULL},
	 { "delete_BoxMullerLecuyerGaussianRng", _wrap_delete_BoxMullerLecuyerGaussianRng, METH_O, NULL},
	 { "BoxMullerLecuyerGaussianRng_swigregister", BoxMullerLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerLecuyerGaussianRng_swiginit", BoxMullerLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerKnuthGaussianRng", _wrap_new_BoxMullerKnuthGaussianRng, METH_O, NULL},
	 { "BoxMullerKnuthGaussianRng_next", _wrap_BoxMullerKnuthGaussianRng_next, METH_O, NULL},
	 { "delete_BoxMullerKnuthGaussianRng", _wrap_delete_BoxMullerKnuthGaussianRng, METH_O, NULL},
	 { "BoxMullerKnuthGaussianRng_swigregister", BoxMullerKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerKnuthGaussianRng_swiginit", BoxMullerKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerMersenneTwisterGaussianRng", _wrap_new_BoxMullerMersenneTwisterGaussianRng, METH_O, NULL},
	 { "BoxMullerMersenneTwisterGaussianRng_next", _wrap_BoxMullerMersenneTwisterGaussianRng_next, METH_O, NULL},
	 { "delete_BoxMullerMersenneTwisterGaussianRng", _wrap_delete_BoxMullerMersenneTwisterGaussianRng, METH_O, NULL},
	 { "BoxMullerMersenneTwisterGaussianRng_swigregister", BoxMullerMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerMersenneTwisterGaussianRng_swiginit", BoxMullerMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeLecuyerGaussianRng", _wrap_new_MoroInvCumulativeLecuyerGaussianRng, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRng_next", _wrap_MoroInvCumulativeLecuyerGaussianRng_next, METH_O, NULL},
	 { "delete_MoroInvCumulativeLecuyerGaussianRng", _wrap_delete_MoroInvCumulativeLecuyerGaussianRng, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRng_swigregister", MoroInvCumulativeLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRng_swiginit", MoroInvCumulativeLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeKnuthGaussianRng", _wrap_new_MoroInvCumulativeKnuthGaussianRng, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRng_next", _wrap_MoroInvCumulativeKnuthGaussianRng_next, METH_O, NULL},
	 { "delete_MoroInvCumulativeKnuthGaussianRng", _wrap_delete_MoroInvCumulativeKnuthGaussianRng, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRng_swigregister", MoroInvCumulativeKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRng_swiginit", MoroInvCumulativeKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeMersenneTwisterGaussianRng", _wrap_new_MoroInvCumulativeMersenneTwisterGaussianRng, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRng_next", _wrap_MoroInvCumulativeMersenneTwisterGaussianRng_next, METH_O, NULL},
	 { "delete_MoroInvCumulativeMersenneTwisterGaussianRng", _wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRng, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRng_swigregister", MoroInvCumulativeMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRng_swiginit", MoroInvCumulativeMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeLecuyerGaussianRng", _wrap_new_InvCumulativeLecuyerGaussianRng, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRng_next", _wrap_InvCumulativeLecuyerGaussianRng_next, METH_O, NULL},
	 { "delete_InvCumulativeLecuyerGaussianRng", _wrap_delete_InvCumulativeLecuyerGaussianRng, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRng_swigregister", InvCumulativeLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRng_swiginit", InvCumulativeLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeKnuthGaussianRng", _wrap_new_InvCumulativeKnuthGaussianRng, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRng_next", _wrap_InvCumulativeKnuthGaussianRng_next, METH_O, NULL},
	 { "delete_InvCumulativeKnuthGaussianRng", _wrap_delete_InvCumulativeKnuthGaussianRng, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRng_swigregister", InvCumulativeKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRng_swiginit", InvCumulativeKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeMersenneTwisterGaussianRng", _wrap_new_InvCumulativeMersenneTwisterGaussianRng, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRng_next", _wrap_InvCumulativeMersenneTwisterGaussianRng_next, METH_O, NULL},
	 { "delete_InvCumulativeMersenneTwisterGaussianRng", _wrap_delete_InvCumulativeMersenneTwisterGaussianRng, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRng_swigregister", InvCumulativeMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRng_swiginit", InvCumulativeMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianRandomGenerator", _wrap_new_GaussianRandomGenerator, METH_O, NULL},
	 { "GaussianRandomGenerator_next", _wrap_GaussianRandomGenerator_next, METH_O, NULL},
	 { "GaussianRandomGenerator_nextValue", _wrap_GaussianRandomGenerator_nextValue, METH_O, NULL},
	 { "delete_GaussianRandomGenerator", _wrap_delete_GaussianRandomGenerator, METH_O, NULL},
	 { "GaussianRandomGenerator_swigregister", GaussianRandomGenerator_swigregister, METH_O, NULL},
	 { "GaussianRandomGenerator_swiginit", GaussianRandomGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_HaltonRsg", _wrap_new_HaltonRsg, METH_VARARGS, NULL},
	 { "HaltonRsg_nextSequence", _wrap_HaltonRsg_nextSequence, METH_O, NULL},
	 { "HaltonRsg_lastSequence", _wrap_HaltonRsg_lastSequence, METH_O, NULL},
	 { "HaltonRsg_dimension", _wrap_HaltonRsg_dimension, METH_O, NULL},
	 { "delete_HaltonRsg", _wrap_delete_HaltonRsg, METH_O, NULL},
	 { "HaltonRsg_swigregister", HaltonRsg_swigregister, METH_O, NULL},
	 { "HaltonRsg_swiginit", HaltonRsg_swiginit, METH_VARARGS, NULL},
	 { "new_SobolRsg", _wrap_new_SobolRsg, METH_VARARGS, NULL},
	 { "SobolRsg_nextSequence", _wrap_SobolRsg_nextSequence, METH_O, NULL},
	 { "SobolRsg_lastSequence", _wrap_SobolRsg_lastSequence, METH_O, NULL},
	 { "SobolRsg_dimension", _wrap_SobolRsg_dimension, METH_O, NULL},
	 { "SobolRsg_skipTo", _wrap_SobolRsg_skipTo, METH_VARARGS, NULL},
	 { "SobolRsg_nextInt32Sequence", _wrap_SobolRsg_nextInt32Sequence, METH_O, NULL},
	 { "delete_SobolRsg", _wrap_delete_SobolRsg, METH_O, NULL},
	 { "SobolRsg_swigregister", SobolRsg_swigregister, METH_O, NULL},
	 { "SobolRsg_swiginit", SobolRsg_swiginit, METH_VARARGS, NULL},
	 { "new_SobolBrownianBridgeRsg", _wrap_new_SobolBrownianBridgeRsg, METH_VARARGS, NULL},
	 { "SobolBrownianBridgeRsg_nextSequence", _wrap_SobolBrownianBridgeRsg_nextSequence, METH_O, NULL},
	 { "SobolBrownianBridgeRsg_lastSequence", _wrap_SobolBrownianBridgeRsg_lastSequence, METH_O, NULL},
	 { "SobolBrownianBridgeRsg_dimension", _wrap_SobolBrownianBridgeRsg_dimension, METH_O, NULL},
	 { "delete_SobolBrownianBridgeRsg", _wrap_delete_SobolBrownianBridgeRsg, METH_O, NULL},
	 { "SobolBrownianBridgeRsg_swigregister", SobolBrownianBridgeRsg_swigregister, METH_O, NULL},
	 { "SobolBrownianBridgeRsg_swiginit", SobolBrownianBridgeRsg_swiginit, METH_VARARGS, NULL},
	 { "new_LecuyerUniformRsg", _wrap_new_LecuyerUniformRsg, METH_VARARGS, NULL},
	 { "LecuyerUniformRsg_nextSequence", _wrap_LecuyerUniformRsg_nextSequence, METH_O, NULL},
	 { "LecuyerUniformRsg_dimension", _wrap_LecuyerUniformRsg_dimension, METH_O, NULL},
	 { "delete_LecuyerUniformRsg", _wrap_delete_LecuyerUniformRsg, METH_O, NULL},
	 { "LecuyerUniformRsg_swigregister", LecuyerUniformRsg_swigregister, METH_O, NULL},
	 { "LecuyerUniformRsg_swiginit", LecuyerUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_KnuthUniformRsg", _wrap_new_KnuthUniformRsg, METH_VARARGS, NULL},
	 { "KnuthUniformRsg_nextSequence", _wrap_KnuthUniformRsg_nextSequence, METH_O, NULL},
	 { "KnuthUniformRsg_dimension", _wrap_KnuthUniformRsg_dimension, METH_O, NULL},
	 { "delete_KnuthUniformRsg", _wrap_delete_KnuthUniformRsg, METH_O, NULL},
	 { "KnuthUniformRsg_swigregister", KnuthUniformRsg_swigregister, METH_O, NULL},
	 { "KnuthUniformRsg_swiginit", KnuthUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MersenneTwisterUniformRsg", _wrap_new_MersenneTwisterUniformRsg, METH_VARARGS, NULL},
	 { "MersenneTwisterUniformRsg_nextSequence", _wrap_MersenneTwisterUniformRsg_nextSequence, METH_O, NULL},
	 { "MersenneTwisterUniformRsg_dimension", _wrap_MersenneTwisterUniformRsg_dimension, METH_O, NULL},
	 { "delete_MersenneTwisterUniformRsg", _wrap_delete_MersenneTwisterUniformRsg, METH_O, NULL},
	 { "MersenneTwisterUniformRsg_swigregister", MersenneTwisterUniformRsg_swigregister, METH_O, NULL},
	 { "MersenneTwisterUniformRsg_swiginit", MersenneTwisterUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_UniformRandomSequenceGenerator", _wrap_new_UniformRandomSequenceGenerator, METH_VARARGS, NULL},
	 { "UniformRandomSequenceGenerator_nextSequence", _wrap_UniformRandomSequenceGenerator_nextSequence, METH_O, NULL},
	 { "UniformRandomSequenceGenerator_dimension", _wrap_UniformRandomSequenceGenerator_dimension, METH_O, NULL},
	 { "delete_UniformRandomSequenceGenerator", _wrap_delete_UniformRandomSequenceGenerator, METH_O, NULL},
	 { "UniformRandomSequenceGenerator_swigregister", UniformRandomSequenceGenerator_swigregister, METH_O, NULL},
	 { "UniformRandomSequenceGenerator_swiginit", UniformRandomSequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_UniformLowDiscrepancySequenceGenerator", _wrap_new_UniformLowDiscrepancySequenceGenerator, METH_VARARGS, NULL},
	 { "UniformLowDiscrepancySequenceGenerator_nextSequence", _wrap_UniformLowDiscrepancySequenceGenerator_nextSequence, METH_O, NULL},
	 { "UniformLowDiscrepancySequenceGenerator_dimension", _wrap_UniformLowDiscrepancySequenceGenerator_dimension, METH_O, NULL},
	 { "delete_UniformLowDiscrepancySequenceGenerator", _wrap_delete_UniformLowDiscrepancySequenceGenerator, METH_O, NULL},
	 { "UniformLowDiscrepancySequenceGenerator_swigregister", UniformLowDiscrepancySequenceGenerator_swigregister, METH_O, NULL},
	 { "UniformLowDiscrepancySequenceGenerator_swiginit", UniformLowDiscrepancySequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeLecuyerGaussianRsg", _wrap_new_MoroInvCumulativeLecuyerGaussianRsg, METH_VARARGS, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRsg_nextSequence", _wrap_MoroInvCumulativeLecuyerGaussianRsg_nextSequence, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRsg_dimension", _wrap_MoroInvCumulativeLecuyerGaussianRsg_dimension, METH_O, NULL},
	 { "delete_MoroInvCumulativeLecuyerGaussianRsg", _wrap_delete_MoroInvCumulativeLecuyerGaussianRsg, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRsg_swigregister", MoroInvCumulativeLecuyerGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRsg_swiginit", MoroInvCumulativeLecuyerGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeKnuthGaussianRsg", _wrap_new_MoroInvCumulativeKnuthGaussianRsg, METH_VARARGS, NULL},
	 { "MoroInvCumulativeKnuthGaussianRsg_nextSequence", _wrap_MoroInvCumulativeKnuthGaussianRsg_nextSequence, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRsg_dimension", _wrap_MoroInvCumulativeKnuthGaussianRsg_dimension, METH_O, NULL},
	 { "delete_MoroInvCumulativeKnuthGaussianRsg", _wrap_delete_MoroInvCumulativeKnuthGaussianRsg, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRsg_swigregister", MoroInvCumulativeKnuthGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRsg_swiginit", MoroInvCumulativeKnuthGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeMersenneTwisterGaussianRsg", _wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg, METH_VARARGS, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence", _wrap_MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_dimension", _wrap_MoroInvCumulativeMersenneTwisterGaussianRsg_dimension, METH_O, NULL},
	 { "delete_MoroInvCumulativeMersenneTwisterGaussianRsg", _wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRsg, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister", MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit", MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeHaltonGaussianRsg", _wrap_new_MoroInvCumulativeHaltonGaussianRsg, METH_VARARGS, NULL},
	 { "MoroInvCumulativeHaltonGaussianRsg_nextSequence", _wrap_MoroInvCumulativeHaltonGaussianRsg_nextSequence, METH_O, NULL},
	 { "MoroInvCumulativeHaltonGaussianRsg_dimension", _wrap_MoroInvCumulativeHaltonGaussianRsg_dimension, METH_O, NULL},
	 { "delete_MoroInvCumulativeHaltonGaussianRsg", _wrap_delete_MoroInvCumulativeHaltonGaussianRsg, METH_O, NULL},
	 { "MoroInvCumulativeHaltonGaussianRsg_swigregister", MoroInvCumulativeHaltonGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeHaltonGaussianRsg_swiginit", MoroInvCumulativeHaltonGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeSobolGaussianRsg", _wrap_new_MoroInvCumulativeSobolGaussianRsg, METH_VARARGS, NULL},
	 { "MoroInvCumulativeSobolGaussianRsg_nextSequence", _wrap_MoroInvCumulativeSobolGaussianRsg_nextSequence, METH_O, NULL},
	 { "MoroInvCumulativeSobolGaussianRsg_dimension", _wrap_MoroInvCumulativeSobolGaussianRsg_dimension, METH_O, NULL},
	 { "delete_MoroInvCumulativeSobolGaussianRsg", _wrap_delete_MoroInvCumulativeSobolGaussianRsg, METH_O, NULL},
	 { "MoroInvCumulativeSobolGaussianRsg_swigregister", MoroInvCumulativeSobolGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeSobolGaussianRsg_swiginit", MoroInvCumulativeSobolGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeLecuyerGaussianRsg", _wrap_new_InvCumulativeLecuyerGaussianRsg, METH_VARARGS, NULL},
	 { "InvCumulativeLecuyerGaussianRsg_nextSequence", _wrap_InvCumulativeLecuyerGaussianRsg_nextSequence, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRsg_dimension", _wrap_InvCumulativeLecuyerGaussianRsg_dimension, METH_O, NULL},
	 { "delete_InvCumulativeLecuyerGaussianRsg", _wrap_delete_InvCumulativeLecuyerGaussianRsg, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRsg_swigregister", InvCumulativeLecuyerGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRsg_swiginit", InvCumulativeLecuyerGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeKnuthGaussianRsg", _wrap_new_InvCumulativeKnuthGaussianRsg, METH_VARARGS, NULL},
	 { "InvCumulativeKnuthGaussianRsg_nextSequence", _wrap_InvCumulativeKnuthGaussianRsg_nextSequence, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRsg_dimension", _wrap_InvCumulativeKnuthGaussianRsg_dimension, METH_O, NULL},
	 { "delete_InvCumulativeKnuthGaussianRsg", _wrap_delete_InvCumulativeKnuthGaussianRsg, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRsg_swigregister", InvCumulativeKnuthGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRsg_swiginit", InvCumulativeKnuthGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeMersenneTwisterGaussianRsg", _wrap_new_InvCumulativeMersenneTwisterGaussianRsg, METH_VARARGS, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRsg_nextSequence", _wrap_InvCumulativeMersenneTwisterGaussianRsg_nextSequence, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRsg_dimension", _wrap_InvCumulativeMersenneTwisterGaussianRsg_dimension, METH_O, NULL},
	 { "delete_InvCumulativeMersenneTwisterGaussianRsg", _wrap_delete_InvCumulativeMersenneTwisterGaussianRsg, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRsg_swigregister", InvCumulativeMersenneTwisterGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRsg_swiginit", InvCumulativeMersenneTwisterGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeHaltonGaussianRsg", _wrap_new_InvCumulativeHaltonGaussianRsg, METH_VARARGS, NULL},
	 { "InvCumulativeHaltonGaussianRsg_nextSequence", _wrap_InvCumulativeHaltonGaussianRsg_nextSequence, METH_O, NULL},
	 { "InvCumulativeHaltonGaussianRsg_dimension", _wrap_InvCumulativeHaltonGaussianRsg_dimension, METH_O, NULL},
	 { "delete_InvCumulativeHaltonGaussianRsg", _wrap_delete_InvCumulativeHaltonGaussianRsg, METH_O, NULL},
	 { "InvCumulativeHaltonGaussianRsg_swigregister", InvCumulativeHaltonGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeHaltonGaussianRsg_swiginit", InvCumulativeHaltonGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeSobolGaussianRsg", _wrap_new_InvCumulativeSobolGaussianRsg, METH_VARARGS, NULL},
	 { "InvCumulativeSobolGaussianRsg_nextSequence", _wrap_InvCumulativeSobolGaussianRsg_nextSequence, METH_O, NULL},
	 { "InvCumulativeSobolGaussianRsg_dimension", _wrap_InvCumulativeSobolGaussianRsg_dimension, METH_O, NULL},
	 { "delete_InvCumulativeSobolGaussianRsg", _wrap_delete_InvCumulativeSobolGaussianRsg, METH_O, NULL},
	 { "InvCumulativeSobolGaussianRsg_swigregister", InvCumulativeSobolGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeSobolGaussianRsg_swiginit", InvCumulativeSobolGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianRandomSequenceGenerator", _wrap_new_GaussianRandomSequenceGenerator, METH_O, NULL},
	 { "GaussianRandomSequenceGenerator_nextSequence", _wrap_GaussianRandomSequenceGenerator_nextSequence, METH_O, NULL},
	 { "GaussianRandomSequenceGenerator_dimension", _wrap_GaussianRandomSequenceGenerator_dimension, METH_O, NULL},
	 { "delete_GaussianRandomSequenceGenerator", _wrap_delete_GaussianRandomSequenceGenerator, METH_O, NULL},
	 { "GaussianRandomSequenceGenerator_swigregister", GaussianRandomSequenceGenerator_swigregister, METH_O, NULL},
	 { "GaussianRandomSequenceGenerator_swiginit", GaussianRandomSequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianLowDiscrepancySequenceGenerator", _wrap_new_GaussianLowDiscrepancySequenceGenerator, METH_O, NULL},
	 { "GaussianLowDiscrepancySequenceGenerator_nextSequence", _wrap_GaussianLowDiscrepancySequenceGenerator_nextSequence, METH_O, NULL},
	 { "GaussianLowDiscrepancySequenceGenerator_dimension", _wrap_GaussianLowDiscrepancySequenceGenerator_dimension, METH_O, NULL},
	 { "delete_GaussianLowDiscrepancySequenceGenerator", _wrap_delete_GaussianLowDiscrepancySequenceGenerator, METH_O, NULL},
	 { "GaussianLowDiscrepancySequenceGenerator_swigregister", GaussianLowDiscrepancySequenceGenerator_swigregister, METH_O, NULL},
	 { "GaussianLowDiscrepancySequenceGenerator_swiginit", GaussianLowDiscrepancySequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "getCovariance", _wrap_getCovariance, METH_VARARGS, NULL},
	 { "Path___len__", _wrap_Path___len__, METH_O, NULL},
	 { "Path_value", _wrap_Path_value, METH_VARARGS, NULL},
	 { "Path_front", _wrap_Path_front, METH_O, NULL},
	 { "Path_back", _wrap_Path_back, METH_O, NULL},
	 { "Path_time", _wrap_Path_time, METH_VARARGS, NULL},
	 { "Path___getitem__", _wrap_Path___getitem__, METH_VARARGS, NULL},
	 { "delete_Path", _wrap_delete_Path, METH_O, NULL},
	 { "Path_swigregister", Path_swigregister, METH_O, NULL},
	 { "SamplePath_value", _wrap_SamplePath_value, METH_O, NULL},
	 { "SamplePath_weight", _wrap_SamplePath_weight, METH_O, NULL},
	 { "delete_SamplePath", _wrap_delete_SamplePath, METH_O, NULL},
	 { "SamplePath_swigregister", SamplePath_swigregister, METH_O, NULL},
	 { "new_GaussianPathGenerator", _wrap_new_GaussianPathGenerator, METH_VARARGS, NULL},
	 { "GaussianPathGenerator_next", _wrap_GaussianPathGenerator_next, METH_O, NULL},
	 { "GaussianPathGenerator_antithetic", _wrap_GaussianPathGenerator_antithetic, METH_O, NULL},
	 { "GaussianPathGenerator_size", _wrap_GaussianPathGenerator_size, METH_O, NULL},
	 { "GaussianPathGenerator_timeGrid", _wrap_GaussianPathGenerator_timeGrid, METH_O, NULL},
	 { "delete_GaussianPathGenerator", _wrap_delete_GaussianPathGenerator, METH_O, NULL},
	 { "GaussianPathGenerator_swigregister", GaussianPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianPathGenerator_swiginit", GaussianPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianSobolPathGenerator", _wrap_new_GaussianSobolPathGenerator, METH_VARARGS, NULL},
	 { "GaussianSobolPathGenerator_next", _wrap_GaussianSobolPathGenerator_next, METH_O, NULL},
	 { "GaussianSobolPathGenerator_antithetic", _wrap_GaussianSobolPathGenerator_antithetic, METH_O, NULL},
	 { "GaussianSobolPathGenerator_size", _wrap_GaussianSobolPathGenerator_size, METH_O, NULL},
	 { "GaussianSobolPathGenerator_timeGrid", _wrap_GaussianSobolPathGenerator_timeGrid, METH_O, NULL},
	 { "delete_GaussianSobolPathGenerator", _wrap_delete_GaussianSobolPathGenerator, METH_O, NULL},
	 { "GaussianSobolPathGenerator_swigregister", GaussianSobolPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianSobolPathGenerator_swiginit", GaussianSobolPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeMersenneTwisterPathGenerator", _wrap_new_InvCumulativeMersenneTwisterPathGenerator, METH_VARARGS, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_next", _wrap_InvCumulativeMersenneTwisterPathGenerator_next, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_antithetic", _wrap_InvCumulativeMersenneTwisterPathGenerator_antithetic, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_size", _wrap_InvCumulativeMersenneTwisterPathGenerator_size, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_timeGrid", _wrap_InvCumulativeMersenneTwisterPathGenerator_timeGrid, METH_O, NULL},
	 { "delete_InvCumulativeMersenneTwisterPathGenerator", _wrap_delete_InvCumulativeMersenneTwisterPathGenerator, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_swigregister", InvCumulativeMersenneTwisterPathGenerator_swigregister, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_swiginit", InvCumulativeMersenneTwisterPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "MultiPath___len__", _wrap_MultiPath___len__, METH_O, NULL},
	 { "MultiPath_assetNumber", _wrap_MultiPath_assetNumber, METH_O, NULL},
	 { "MultiPath_at", _wrap_MultiPath_at, METH_VARARGS, NULL},
	 { "MultiPath___getitem__", _wrap_MultiPath___getitem__, METH_VARARGS, NULL},
	 { "delete_MultiPath", _wrap_delete_MultiPath, METH_O, NULL},
	 { "MultiPath_swigregister", MultiPath_swigregister, METH_O, NULL},
	 { "SampleMultiPath_value", _wrap_SampleMultiPath_value, METH_O, NULL},
	 { "SampleMultiPath_weight", _wrap_SampleMultiPath_weight, METH_O, NULL},
	 { "delete_SampleMultiPath", _wrap_delete_SampleMultiPath, METH_O, NULL},
	 { "SampleMultiPath_swigregister", SampleMultiPath_swigregister, METH_O, NULL},
	 { "new_GaussianMultiPathGenerator", _wrap_new_GaussianMultiPathGenerator, METH_VARARGS, NULL},
	 { "GaussianMultiPathGenerator_next", _wrap_GaussianMultiPathGenerator_next, METH_O, NULL},
	 { "GaussianMultiPathGenerator_antithetic", _wrap_GaussianMultiPathGenerator_antithetic, METH_O, NULL},
	 { "delete_GaussianMultiPathGenerator", _wrap_delete_GaussianMultiPathGenerator, METH_O, NULL},
	 { "GaussianMultiPathGenerator_swigregister", GaussianMultiPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianMultiPathGenerator_swiginit", GaussianMultiPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_BrownianBridge", _wrap_new_BrownianBridge, METH_VARARGS, NULL},
	 { "BrownianBridge_size", _wrap_BrownianBridge_size, METH_O, NULL},
	 { "BrownianBridge_times", _wrap_BrownianBridge_times, METH_O, NULL},
	 { "BrownianBridge_leftWeight", _wrap_BrownianBridge_leftWeight, METH_O, NULL},
	 { "BrownianBridge_rightWeight", _wrap_BrownianBridge_rightWeight, METH_O, NULL},
	 { "BrownianBridge_stdDeviation", _wrap_BrownianBridge_stdDeviation, METH_O, NULL},
	 { "BrownianBridge_transform", _wrap_BrownianBridge_transform, METH_VARARGS, NULL},
	 { "BrownianBridge_bridgeIndex", _wrap_BrownianBridge_bridgeIndex, METH_O, NULL},
	 { "BrownianBridge_leftIndex", _wrap_BrownianBridge_leftIndex, METH_O, NULL},
	 { "BrownianBridge_rightIndex", _wrap_BrownianBridge_rightIndex, METH_O, NULL},
	 { "delete_BrownianBridge", _wrap_delete_BrownianBridge, METH_O, NULL},
	 { "BrownianBridge_swigregister", BrownianBridge_swigregister, METH_O, NULL},
	 { "BrownianBridge_swiginit", BrownianBridge_swiginit, METH_VARARGS, NULL},
	 { "new_RungeKutta", _wrap_new_RungeKutta, METH_VARARGS, NULL},
	 { "RungeKutta___call__", _wrap_RungeKutta___call__, METH_VARARGS, NULL},
	 { "delete_RungeKutta", _wrap_delete_RungeKutta, METH_O, NULL},
	 { "RungeKutta_swigregister", RungeKutta_swigregister, METH_O, NULL},
	 { "RungeKutta_swiginit", RungeKutta_swiginit, METH_VARARGS, NULL},
	 { "delete_DefaultBoundaryCondition", _wrap_delete_DefaultBoundaryCondition, METH_O, NULL},
	 { "DefaultBoundaryCondition_swigregister", DefaultBoundaryCondition_swigregister, METH_O, NULL},
	 { "new_NeumannBC", _wrap_new_NeumannBC, METH_VARARGS, NULL},
	 { "delete_NeumannBC", _wrap_delete_NeumannBC, METH_O, NULL},
	 { "NeumannBC_swigregister", NeumannBC_swigregister, METH_O, NULL},
	 { "NeumannBC_swiginit", NeumannBC_swiginit, METH_VARARGS, NULL},
	 { "new_DirichletBC", _wrap_new_DirichletBC, METH_VARARGS, NULL},
	 { "delete_DirichletBC", _wrap_delete_DirichletBC, METH_O, NULL},
	 { "DirichletBC_swigregister", DirichletBC_swigregister, METH_O, NULL},
	 { "DirichletBC_swiginit", DirichletBC_swiginit, METH_VARARGS, NULL},
	 { "new_TridiagonalOperator", _wrap_new_TridiagonalOperator, METH_VARARGS, NULL},
	 { "TridiagonalOperator_solveFor", _wrap_TridiagonalOperator_solveFor, METH_VARARGS, NULL},
	 { "TridiagonalOperator_applyTo", _wrap_TridiagonalOperator_applyTo, METH_VARARGS, NULL},
	 { "TridiagonalOperator_size", _wrap_TridiagonalOperator_size, METH_O, NULL},
	 { "TridiagonalOperator_setFirstRow", _wrap_TridiagonalOperator_setFirstRow, METH_VARARGS, NULL},
	 { "TridiagonalOperator_setMidRow", _wrap_TridiagonalOperator_setMidRow, METH_VARARGS, NULL},
	 { "TridiagonalOperator_setMidRows", _wrap_TridiagonalOperator_setMidRows, METH_VARARGS, NULL},
	 { "TridiagonalOperator_setLastRow", _wrap_TridiagonalOperator_setLastRow, METH_VARARGS, NULL},
	 { "TridiagonalOperator_identity", _wrap_TridiagonalOperator_identity, METH_O, NULL},
	 { "TridiagonalOperator___add__", _wrap_TridiagonalOperator___add__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___sub__", _wrap_TridiagonalOperator___sub__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___mul__", _wrap_TridiagonalOperator___mul__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___div__", _wrap_TridiagonalOperator___div__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___iadd__", _wrap_TridiagonalOperator___iadd__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___isub__", _wrap_TridiagonalOperator___isub__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___imul__", _wrap_TridiagonalOperator___imul__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___rmul__", _wrap_TridiagonalOperator___rmul__, METH_VARARGS, NULL},
	 { "TridiagonalOperator___idiv__", _wrap_TridiagonalOperator___idiv__, METH_VARARGS, NULL},
	 { "delete_TridiagonalOperator", _wrap_delete_TridiagonalOperator, METH_O, NULL},
	 { "TridiagonalOperator_swigregister", TridiagonalOperator_swigregister, METH_O, NULL},
	 { "TridiagonalOperator_swiginit", TridiagonalOperator_swiginit, METH_VARARGS, NULL},
	 { "new_DPlus", _wrap_new_DPlus, METH_VARARGS, NULL},
	 { "delete_DPlus", _wrap_delete_DPlus, METH_O, NULL},
	 { "DPlus_swigregister", DPlus_swigregister, METH_O, NULL},
	 { "DPlus_swiginit", DPlus_swiginit, METH_VARARGS, NULL},
	 { "new_DMinus", _wrap_new_DMinus, METH_VARARGS, NULL},
	 { "delete_DMinus", _wrap_delete_DMinus, METH_O, NULL},
	 { "DMinus_swigregister", DMinus_swigregister, METH_O, NULL},
	 { "DMinus_swiginit", DMinus_swiginit, METH_VARARGS, NULL},
	 { "new_DZero", _wrap_new_DZero, METH_VARARGS, NULL},
	 { "delete_DZero", _wrap_delete_DZero, METH_O, NULL},
	 { "DZero_swigregister", DZero_swigregister, METH_O, NULL},
	 { "DZero_swiginit", DZero_swiginit, METH_VARARGS, NULL},
	 { "new_DPlusDMinus", _wrap_new_DPlusDMinus, METH_VARARGS, NULL},
	 { "delete_DPlusDMinus", _wrap_delete_DPlusDMinus, METH_O, NULL},
	 { "DPlusDMinus_swigregister", DPlusDMinus_swigregister, METH_O, NULL},
	 { "DPlusDMinus_swiginit", DPlusDMinus_swiginit, METH_VARARGS, NULL},
	 { "new_SampledCurve", _wrap_new_SampledCurve, METH_VARARGS, NULL},
	 { "SampledCurve_grid", _wrap_SampledCurve_grid, METH_O, NULL},
	 { "SampledCurve_values", _wrap_SampledCurve_values, METH_O, NULL},
	 { "SampledCurve_gridValue", _wrap_SampledCurve_gridValue, METH_VARARGS, NULL},
	 { "SampledCurve_value", _wrap_SampledCurve_value, METH_VARARGS, NULL},
	 { "SampledCurve_size", _wrap_SampledCurve_size, METH_O, NULL},
	 { "SampledCurve_empty", _wrap_SampledCurve_empty, METH_O, NULL},
	 { "SampledCurve_setGrid", _wrap_SampledCurve_setGrid, METH_VARARGS, NULL},
	 { "SampledCurve_setValues", _wrap_SampledCurve_setValues, METH_VARARGS, NULL},
	 { "SampledCurve_swap", _wrap_SampledCurve_swap, METH_VARARGS, NULL},
	 { "SampledCurve_setLogGrid", _wrap_SampledCurve_setLogGrid, METH_VARARGS, NULL},
	 { "SampledCurve_regridLogGrid", _wrap_SampledCurve_regridLogGrid, METH_VARARGS, NULL},
	 { "SampledCurve_shiftGrid", _wrap_SampledCurve_shiftGrid, METH_VARARGS, NULL},
	 { "SampledCurve_scaleGrid", _wrap_SampledCurve_scaleGrid, METH_VARARGS, NULL},
	 { "SampledCurve_regrid", _wrap_SampledCurve_regrid, METH_VARARGS, NULL},
	 { "delete_SampledCurve", _wrap_delete_SampledCurve, METH_O, NULL},
	 { "SampledCurve_swigregister", SampledCurve_swigregister, METH_O, NULL},
	 { "SampledCurve_swiginit", SampledCurve_swiginit, METH_VARARGS, NULL},
	 { "new_HestonSLVProcess", _wrap_new_HestonSLVProcess, METH_VARARGS, NULL},
	 { "delete_HestonSLVProcess", _wrap_delete_HestonSLVProcess, METH_O, NULL},
	 { "HestonSLVProcess_swigregister", HestonSLVProcess_swigregister, METH_O, NULL},
	 { "HestonSLVProcess_swiginit", HestonSLVProcess_swiginit, METH_VARARGS, NULL},
	 { "delete_BrownianGeneratorFactory", _wrap_delete_BrownianGeneratorFactory, METH_O, NULL},
	 { "BrownianGeneratorFactory_swigregister", BrownianGeneratorFactory_swigregister, METH_O, NULL},
	 { "new_MTBrownianGeneratorFactory", _wrap_new_MTBrownianGeneratorFactory, METH_VARARGS, NULL},
	 { "delete_MTBrownianGeneratorFactory", _wrap_delete_MTBrownianGeneratorFactory, METH_O, NULL},
	 { "MTBrownianGeneratorFactory_swigregister", MTBrownianGeneratorFactory_swigregister, METH_O, NULL},
	 { "MTBrownianGeneratorFactory_swiginit", MTBrownianGeneratorFactory_swiginit, METH_VARARGS, NULL},
	 { "delete_SobolBrownianGenerator", _wrap_delete_SobolBrownianGenerator, METH_O, NULL},
	 { "SobolBrownianGenerator_swigregister", SobolBrownianGenerator_swigregister, METH_O, NULL},
	 { "new_SobolBrownianGeneratorFactory", _wrap_new_SobolBrownianGeneratorFactory, METH_VARARGS, NULL},
	 { "delete_SobolBrownianGeneratorFactory", _wrap_delete_SobolBrownianGeneratorFactory, METH_O, NULL},
	 { "SobolBrownianGeneratorFactory_swigregister", SobolBrownianGeneratorFactory_swigregister, METH_O, NULL},
	 { "SobolBrownianGeneratorFactory_swiginit", SobolBrownianGeneratorFactory_swiginit, METH_VARARGS, NULL},
	 { "new_HestonSLVMCModel", _wrap_new_HestonSLVMCModel, METH_VARARGS, NULL},
	 { "HestonSLVMCModel_hestonProcess", _wrap_HestonSLVMCModel_hestonProcess, METH_O, NULL},
	 { "HestonSLVMCModel_localVol", _wrap_HestonSLVMCModel_localVol, METH_O, NULL},
	 { "HestonSLVMCModel_leverageFunction", _wrap_HestonSLVMCModel_leverageFunction, METH_O, NULL},
	 { "delete_HestonSLVMCModel", _wrap_delete_HestonSLVMCModel, METH_O, NULL},
	 { "HestonSLVMCModel_swigregister", HestonSLVMCModel_swigregister, METH_O, NULL},
	 { "HestonSLVMCModel_swiginit", HestonSLVMCModel_swiginit, METH_VARARGS, NULL},
	 { "delete_FdmHestonGreensFct", _wrap_delete_FdmHestonGreensFct, METH_O, NULL},
	 { "FdmHestonGreensFct_swigregister", FdmHestonGreensFct_swigregister, METH_O, NULL},
	 { "new_HestonSLVFokkerPlanckFdmParams", _wrap_new_HestonSLVFokkerPlanckFdmParams, METH_VARARGS, NULL},
	 { "delete_HestonSLVFokkerPlanckFdmParams", _wrap_delete_HestonSLVFokkerPlanckFdmParams, METH_O, NULL},
	 { "HestonSLVFokkerPlanckFdmParams_swigregister", HestonSLVFokkerPlanckFdmParams_swigregister, METH_O, NULL},
	 { "HestonSLVFokkerPlanckFdmParams_swiginit", HestonSLVFokkerPlanckFdmParams_swiginit, METH_VARARGS, NULL},
	 { "new_HestonSLVFDMModel", _wrap_new_HestonSLVFDMModel, METH_VARARGS, NULL},
	 { "HestonSLVFDMModel_hestonProcess", _wrap_HestonSLVFDMModel_hestonProcess, METH_O, NULL},
	 { "HestonSLVFDMModel_localVol", _wrap_HestonSLVFDMModel_localVol, METH_O, NULL},
	 { "HestonSLVFDMModel_leverageFunction", _wrap_HestonSLVFDMModel_leverageFunction, METH_O, NULL},
	 { "delete_HestonSLVFDMModel", _wrap_delete_HestonSLVFDMModel, METH_O, NULL},
	 { "HestonSLVFDMModel_swigregister", HestonSLVFDMModel_swigregister, METH_O, NULL},
	 { "HestonSLVFDMModel_swiginit", HestonSLVFDMModel_swiginit, METH_VARARGS, NULL},
	 { "Statistics_samples", _wrap_Statistics_samples, METH_O, NULL},
	 { "Statistics_weightSum", _wrap_Statistics_weightSum, METH_O, NULL},
	 { "Statistics_mean", _wrap_Statistics_mean, METH_O, NULL},
	 { "Statistics_variance", _wrap_Statistics_variance, METH_O, NULL},
	 { "Statistics_standardDeviation", _wrap_Statistics_standardDeviation, METH_O, NULL},
	 { "Statistics_errorEstimate", _wrap_Statistics_errorEstimate, METH_O, NULL},
	 { "Statistics_skewness", _wrap_Statistics_skewness, METH_O, NULL},
	 { "Statistics_kurtosis", _wrap_Statistics_kurtosis, METH_O, NULL},
	 { "Statistics_min", _wrap_Statistics_min, METH_O, NULL},
	 { "Statistics_max", _wrap_Statistics_max, METH_O, NULL},
	 { "Statistics_reset", _wrap_Statistics_reset, METH_O, NULL},
	 { "Statistics_add", _wrap_Statistics_add, METH_VARARGS, NULL},
	 { "new_Statistics", _wrap_new_Statistics, METH_NOARGS, NULL},
	 { "delete_Statistics", _wrap_delete_Statistics, METH_O, NULL},
	 { "Statistics_swigregister", Statistics_swigregister, METH_O, NULL},
	 { "Statistics_swiginit", Statistics_swiginit, METH_VARARGS, NULL},
	 { "IncrementalStatistics_samples", _wrap_IncrementalStatistics_samples, METH_O, NULL},
	 { "IncrementalStatistics_weightSum", _wrap_IncrementalStatistics_weightSum, METH_O, NULL},
	 { "IncrementalStatistics_mean", _wrap_IncrementalStatistics_mean, METH_O, NULL},
	 { "IncrementalStatistics_variance", _wrap_IncrementalStatistics_variance, METH_O, NULL},
	 { "IncrementalStatistics_standardDeviation", _wrap_IncrementalStatistics_standardDeviation, METH_O, NULL},
	 { "IncrementalStatistics_errorEstimate", _wrap_IncrementalStatistics_errorEstimate, METH_O, NULL},
	 { "IncrementalStatistics_skewness", _wrap_IncrementalStatistics_skewness, METH_O, NULL},
	 { "IncrementalStatistics_kurtosis", _wrap_IncrementalStatistics_kurtosis, METH_O, NULL},
	 { "IncrementalStatistics_min", _wrap_IncrementalStatistics_min, METH_O, NULL},
	 { "IncrementalStatistics_max", _wrap_IncrementalStatistics_max, METH_O, NULL},
	 { "IncrementalStatistics_reset", _wrap_IncrementalStatistics_reset, METH_O, NULL},
	 { "IncrementalStatistics_add", _wrap_IncrementalStatistics_add, METH_VARARGS, NULL},
	 { "new_IncrementalStatistics", _wrap_new_IncrementalStatistics, METH_NOARGS, NULL},
	 { "delete_IncrementalStatistics", _wrap_delete_IncrementalStatistics, METH_O, NULL},
	 { "IncrementalStatistics_swigregister", IncrementalStatistics_swigregister, METH_O, NULL},
	 { "IncrementalStatistics_swiginit", IncrementalStatistics_swiginit, METH_VARARGS, NULL},
	 { "RiskStatistics_semiVariance", _wrap_RiskStatistics_semiVariance, METH_O, NULL},
	 { "RiskStatistics_semiDeviation", _wrap_RiskStatistics_semiDeviation, METH_O, NULL},
	 { "RiskStatistics_downsideVariance", _wrap_RiskStatistics_downsideVariance, METH_O, NULL},
	 { "RiskStatistics_downsideDeviation", _wrap_RiskStatistics_downsideDeviation, METH_O, NULL},
	 { "RiskStatistics_regret", _wrap_RiskStatistics_regret, METH_VARARGS, NULL},
	 { "RiskStatistics_potentialUpside", _wrap_RiskStatistics_potentialUpside, METH_VARARGS, NULL},
	 { "RiskStatistics_valueAtRisk", _wrap_RiskStatistics_valueAtRisk, METH_VARARGS, NULL},
	 { "RiskStatistics_expectedShortfall", _wrap_RiskStatistics_expectedShortfall, METH_VARARGS, NULL},
	 { "RiskStatistics_shortfall", _wrap_RiskStatistics_shortfall, METH_VARARGS, NULL},
	 { "RiskStatistics_averageShortfall", _wrap_RiskStatistics_averageShortfall, METH_VARARGS, NULL},
	 { "new_RiskStatistics", _wrap_new_RiskStatistics, METH_NOARGS, NULL},
	 { "delete_RiskStatistics", _wrap_delete_RiskStatistics, METH_O, NULL},
	 { "RiskStatistics_swigregister", RiskStatistics_swigregister, METH_O, NULL},
	 { "RiskStatistics_swiginit", RiskStatistics_swiginit, METH_VARARGS, NULL},
	 { "new_MultipleStatistics", _wrap_new_MultipleStatistics, METH_O, NULL},
	 { "MultipleStatistics_size", _wrap_MultipleStatistics_size, METH_O, NULL},
	 { "MultipleStatistics_samples", _wrap_MultipleStatistics_samples, METH_O, NULL},
	 { "MultipleStatistics_weightSum", _wrap_MultipleStatistics_weightSum, METH_O, NULL},
	 { "MultipleStatistics_mean", _wrap_MultipleStatistics_mean, METH_O, NULL},
	 { "MultipleStatistics_variance", _wrap_MultipleStatistics_variance, METH_O, NULL},
	 { "MultipleStatistics_standardDeviation", _wrap_MultipleStatistics_standardDeviation, METH_O, NULL},
	 { "MultipleStatistics_errorEstimate", _wrap_MultipleStatistics_errorEstimate, METH_O, NULL},
	 { "MultipleStatistics_skewness", _wrap_MultipleStatistics_skewness, METH_O, NULL},
	 { "MultipleStatistics_kurtosis", _wrap_MultipleStatistics_kurtosis, METH_O, NULL},
	 { "MultipleStatistics_min", _wrap_MultipleStatistics_min, METH_O, NULL},
	 { "MultipleStatistics_max", _wrap_MultipleStatistics_max, METH_O, NULL},
	 { "MultipleStatistics_covariance", _wrap_MultipleStatistics_covariance, METH_O, NULL},
	 { "MultipleStatistics_correlation", _wrap_MultipleStatistics_correlation, METH_O, NULL},
	 { "MultipleStatistics_reset", _wrap_MultipleStatistics_reset, METH_O, NULL},
	 { "MultipleStatistics_add", _wrap_MultipleStatistics_add, METH_VARARGS, NULL},
	 { "delete_MultipleStatistics", _wrap_delete_MultipleStatistics, METH_O, NULL},
	 { "MultipleStatistics_swigregister", MultipleStatistics_swigregister, METH_O, NULL},
	 { "MultipleStatistics_swiginit", MultipleStatistics_swiginit, METH_VARARGS, NULL},
	 { "new_SequenceStatistics", _wrap_new_SequenceStatistics, METH_O, NULL},
	 { "SequenceStatistics_size", _wrap_SequenceStatistics_size, METH_O, NULL},
	 { "SequenceStatistics_samples", _wrap_SequenceStatistics_samples, METH_O, NULL},
	 { "SequenceStatistics_weightSum", _wrap_SequenceStatistics_weightSum, METH_O, NULL},
	 { "SequenceStatistics_mean", _wrap_SequenceStatistics_mean, METH_O, NULL},
	 { "SequenceStatistics_variance", _wrap_SequenceStatistics_variance, METH_O, NULL},
	 { "SequenceStatistics_standardDeviation", _wrap_SequenceStatistics_standardDeviation, METH_O, NULL},
	 { "SequenceStatistics_errorEstimate", _wrap_SequenceStatistics_errorEstimate, METH_O, NULL},
	 { "SequenceStatistics_skewness", _wrap_SequenceStatistics_skewness, METH_O, NULL},
	 { "SequenceStatistics_kurtosis", _wrap_SequenceStatistics_kurtosis, METH_O, NULL},
	 { "SequenceStatistics_min", _wrap_SequenceStatistics_min, METH_O, NULL},
	 { "SequenceStatistics_max", _wrap_SequenceStatistics_max, METH_O, NULL},
	 { "SequenceStatistics_covariance", _wrap_SequenceStatistics_covariance, METH_O, NULL},
	 { "SequenceStatistics_correlation", _wrap_SequenceStatistics_correlation, METH_O, NULL},
	 { "SequenceStatistics_reset", _wrap_SequenceStatistics_reset, METH_O, NULL},
	 { "SequenceStatistics_add", _wrap_SequenceStatistics_add, METH_VARARGS, NULL},
	 { "delete_SequenceStatistics", _wrap_delete_SequenceStatistics, METH_O, NULL},
	 { "SequenceStatistics_swigregister", SequenceStatistics_swigregister, METH_O, NULL},
	 { "SequenceStatistics_swiginit", SequenceStatistics_swiginit, METH_VARARGS, NULL},
	 { "new_MultipleIncrementalStatistics", _wrap_new_MultipleIncrementalStatistics, METH_O, NULL},
	 { "MultipleIncrementalStatistics_size", _wrap_MultipleIncrementalStatistics_size, METH_O, NULL},
	 { "MultipleIncrementalStatistics_samples", _wrap_MultipleIncrementalStatistics_samples, METH_O, NULL},
	 { "MultipleIncrementalStatistics_weightSum", _wrap_MultipleIncrementalStatistics_weightSum, METH_O, NULL},
	 { "MultipleIncrementalStatistics_mean", _wrap_MultipleIncrementalStatistics_mean, METH_O, NULL},
	 { "MultipleIncrementalStatistics_variance", _wrap_MultipleIncrementalStatistics_variance, METH_O, NULL},
	 { "MultipleIncrementalStatistics_standardDeviation", _wrap_MultipleIncrementalStatistics_standardDeviation, METH_O, NULL},
	 { "MultipleIncrementalStatistics_errorEstimate", _wrap_MultipleIncrementalStatistics_errorEstimate, METH_O, NULL},
	 { "MultipleIncrementalStatistics_skewness", _wrap_MultipleIncrementalStatistics_skewness, METH_O, NULL},
	 { "MultipleIncrementalStatistics_kurtosis", _wrap_MultipleIncrementalStatistics_kurtosis, METH_O, NULL},
	 { "MultipleIncrementalStatistics_min", _wrap_MultipleIncrementalStatistics_min, METH_O, NULL},
	 { "MultipleIncrementalStatistics_max", _wrap_MultipleIncrementalStatistics_max, METH_O, NULL},
	 { "MultipleIncrementalStatistics_covariance", _wrap_MultipleIncrementalStatistics_covariance, METH_O, NULL},
	 { "MultipleIncrementalStatistics_correlation", _wrap_MultipleIncrementalStatistics_correlation, METH_O, NULL},
	 { "MultipleIncrementalStatistics_reset", _wrap_MultipleIncrementalStatistics_reset, METH_O, NULL},
	 { "MultipleIncrementalStatistics_add", _wrap_MultipleIncrementalStatistics_add, METH_VARARGS, NULL},
	 { "delete_MultipleIncrementalStatistics", _wrap_delete_MultipleIncrementalStatistics, METH_O, NULL},
	 { "MultipleIncrementalStatistics_swigregister", MultipleIncrementalStatistics_swigregister, METH_O, NULL},
	 { "MultipleIncrementalStatistics_swiginit", MultipleIncrementalStatistics_swiginit, METH_VARARGS, NULL},
	 { "CapFloorTermVolatilityStructure_volatility", _wrap_CapFloorTermVolatilityStructure_volatility, METH_VARARGS, NULL},
	 { "delete_CapFloorTermVolatilityStructure", _wrap_delete_CapFloorTermVolatilityStructure, METH_O, NULL},
	 { "CapFloorTermVolatilityStructure_swigregister", CapFloorTermVolatilityStructure_swigregister, METH_O, NULL},
	 { "new_CapFloorTermVolatilityStructureHandle", _wrap_new_CapFloorTermVolatilityStructureHandle, METH_VARARGS, NULL},
	 { "CapFloorTermVolatilityStructureHandle___deref__", _wrap_CapFloorTermVolatilityStructureHandle___deref__, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_currentLink", _wrap_CapFloorTermVolatilityStructureHandle_currentLink, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle___nonzero__", _wrap_CapFloorTermVolatilityStructureHandle___nonzero__, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle___bool__", _wrap_CapFloorTermVolatilityStructureHandle___bool__, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_asObservable", _wrap_CapFloorTermVolatilityStructureHandle_asObservable, METH_O, NULL},
	 { "delete_CapFloorTermVolatilityStructureHandle", _wrap_delete_CapFloorTermVolatilityStructureHandle, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_volatility", _wrap_CapFloorTermVolatilityStructureHandle_volatility, METH_VARARGS, NULL},
	 { "CapFloorTermVolatilityStructureHandle_minStrike", _wrap_CapFloorTermVolatilityStructureHandle_minStrike, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_maxStrike", _wrap_CapFloorTermVolatilityStructureHandle_maxStrike, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_dayCounter", _wrap_CapFloorTermVolatilityStructureHandle_dayCounter, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_timeFromReference", _wrap_CapFloorTermVolatilityStructureHandle_timeFromReference, METH_VARARGS, NULL},
	 { "CapFloorTermVolatilityStructureHandle_calendar", _wrap_CapFloorTermVolatilityStructureHandle_calendar, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_referenceDate", _wrap_CapFloorTermVolatilityStructureHandle_referenceDate, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_maxDate", _wrap_CapFloorTermVolatilityStructureHandle_maxDate, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_maxTime", _wrap_CapFloorTermVolatilityStructureHandle_maxTime, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_enableExtrapolation", _wrap_CapFloorTermVolatilityStructureHandle_enableExtrapolation, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_disableExtrapolation", _wrap_CapFloorTermVolatilityStructureHandle_disableExtrapolation, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_allowsExtrapolation", _wrap_CapFloorTermVolatilityStructureHandle_allowsExtrapolation, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_swigregister", CapFloorTermVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_swiginit", CapFloorTermVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableCapFloorTermVolatilityStructureHandle", _wrap_new_RelinkableCapFloorTermVolatilityStructureHandle, METH_VARARGS, NULL},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_linkTo", _wrap_RelinkableCapFloorTermVolatilityStructureHandle_linkTo, METH_VARARGS, NULL},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_reset", _wrap_RelinkableCapFloorTermVolatilityStructureHandle_reset, METH_O, NULL},
	 { "delete_RelinkableCapFloorTermVolatilityStructureHandle", _wrap_delete_RelinkableCapFloorTermVolatilityStructureHandle, METH_O, NULL},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_swigregister", RelinkableCapFloorTermVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_swiginit", RelinkableCapFloorTermVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_CapFloorTermVolCurve", _wrap_new_CapFloorTermVolCurve, METH_VARARGS, NULL},
	 { "delete_CapFloorTermVolCurve", _wrap_delete_CapFloorTermVolCurve, METH_O, NULL},
	 { "CapFloorTermVolCurve_swigregister", CapFloorTermVolCurve_swigregister, METH_O, NULL},
	 { "CapFloorTermVolCurve_swiginit", CapFloorTermVolCurve_swiginit, METH_VARARGS, NULL},
	 { "new_CapFloorTermVolSurface", _wrap_new_CapFloorTermVolSurface, METH_VARARGS, NULL},
	 { "CapFloorTermVolSurface_maxDate", _wrap_CapFloorTermVolSurface_maxDate, METH_O, NULL},
	 { "CapFloorTermVolSurface_minStrike", _wrap_CapFloorTermVolSurface_minStrike, METH_O, NULL},
	 { "CapFloorTermVolSurface_maxStrike", _wrap_CapFloorTermVolSurface_maxStrike, METH_O, NULL},
	 { "CapFloorTermVolSurface_optionTenors", _wrap_CapFloorTermVolSurface_optionTenors, METH_O, NULL},
	 { "CapFloorTermVolSurface_optionDates", _wrap_CapFloorTermVolSurface_optionDates, METH_O, NULL},
	 { "CapFloorTermVolSurface_optionTimes", _wrap_CapFloorTermVolSurface_optionTimes, METH_O, NULL},
	 { "CapFloorTermVolSurface_strikes", _wrap_CapFloorTermVolSurface_strikes, METH_O, NULL},
	 { "delete_CapFloorTermVolSurface", _wrap_delete_CapFloorTermVolSurface, METH_O, NULL},
	 { "CapFloorTermVolSurface_swigregister", CapFloorTermVolSurface_swigregister, METH_O, NULL},
	 { "CapFloorTermVolSurface_swiginit", CapFloorTermVolSurface_swiginit, METH_VARARGS, NULL},
	 { "StrippedOptionletBase_optionletStrikes", _wrap_StrippedOptionletBase_optionletStrikes, METH_VARARGS, NULL},
	 { "StrippedOptionletBase_optionletVolatilities", _wrap_StrippedOptionletBase_optionletVolatilities, METH_VARARGS, NULL},
	 { "StrippedOptionletBase_optionletFixingDates", _wrap_StrippedOptionletBase_optionletFixingDates, METH_O, NULL},
	 { "StrippedOptionletBase_optionletFixingTimes", _wrap_StrippedOptionletBase_optionletFixingTimes, METH_O, NULL},
	 { "StrippedOptionletBase_optionletMaturities", _wrap_StrippedOptionletBase_optionletMaturities, METH_O, NULL},
	 { "StrippedOptionletBase_atmOptionletRates", _wrap_StrippedOptionletBase_atmOptionletRates, METH_O, NULL},
	 { "StrippedOptionletBase_dayCounter", _wrap_StrippedOptionletBase_dayCounter, METH_O, NULL},
	 { "StrippedOptionletBase_calendar", _wrap_StrippedOptionletBase_calendar, METH_O, NULL},
	 { "StrippedOptionletBase_settlementDays", _wrap_StrippedOptionletBase_settlementDays, METH_O, NULL},
	 { "StrippedOptionletBase_businessDayConvention", _wrap_StrippedOptionletBase_businessDayConvention, METH_O, NULL},
	 { "delete_StrippedOptionletBase", _wrap_delete_StrippedOptionletBase, METH_O, NULL},
	 { "StrippedOptionletBase_swigregister", StrippedOptionletBase_swigregister, METH_O, NULL},
	 { "new_OptionletStripper1", (PyCFunction)(void(*)(void))_wrap_new_OptionletStripper1, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "OptionletStripper1_capFloorPrices", _wrap_OptionletStripper1_capFloorPrices, METH_O, NULL},
	 { "OptionletStripper1_capFloorVolatilities", _wrap_OptionletStripper1_capFloorVolatilities, METH_O, NULL},
	 { "OptionletStripper1_optionletPrices", _wrap_OptionletStripper1_optionletPrices, METH_O, NULL},
	 { "OptionletStripper1_switchStrike", _wrap_OptionletStripper1_switchStrike, METH_O, NULL},
	 { "delete_OptionletStripper1", _wrap_delete_OptionletStripper1, METH_O, NULL},
	 { "OptionletStripper1_swigregister", OptionletStripper1_swigregister, METH_O, NULL},
	 { "OptionletStripper1_swiginit", OptionletStripper1_swiginit, METH_VARARGS, NULL},
	 { "new_StrippedOptionletAdapter", _wrap_new_StrippedOptionletAdapter, METH_O, NULL},
	 { "delete_StrippedOptionletAdapter", _wrap_delete_StrippedOptionletAdapter, METH_O, NULL},
	 { "StrippedOptionletAdapter_swigregister", StrippedOptionletAdapter_swigregister, METH_O, NULL},
	 { "StrippedOptionletAdapter_swiginit", StrippedOptionletAdapter_swiginit, METH_VARARGS, NULL},
	 { "new_Settlement", _wrap_new_Settlement, METH_NOARGS, NULL},
	 { "delete_Settlement", _wrap_delete_Settlement, METH_O, NULL},
	 { "Settlement_swigregister", Settlement_swigregister, METH_O, NULL},
	 { "Settlement_swiginit", Settlement_swiginit, METH_VARARGS, NULL},
	 { "new_Swaption", _wrap_new_Swaption, METH_VARARGS, NULL},
	 { "Swaption_settlementType", _wrap_Swaption_settlementType, METH_O, NULL},
	 { "Swaption_settlementMethod", _wrap_Swaption_settlementMethod, METH_O, NULL},
	 { "Swaption_type", _wrap_Swaption_type, METH_O, NULL},
	 { "Swaption_underlyingSwap", _wrap_Swaption_underlyingSwap, METH_O, NULL},
	 { "Swaption_impliedVolatility", _wrap_Swaption_impliedVolatility, METH_VARARGS, NULL},
	 { "Swaption_vega", _wrap_Swaption_vega, METH_O, NULL},
	 { "Swaption_delta", _wrap_Swaption_delta, METH_O, NULL},
	 { "Swaption_annuity", _wrap_Swaption_annuity, METH_O, NULL},
	 { "delete_Swaption", _wrap_delete_Swaption, METH_O, NULL},
	 { "Swaption_swigregister", Swaption_swigregister, METH_O, NULL},
	 { "Swaption_swiginit", Swaption_swiginit, METH_VARARGS, NULL},
	 { "new_NonstandardSwaption", _wrap_new_NonstandardSwaption, METH_VARARGS, NULL},
	 { "NonstandardSwaption_underlyingSwap", _wrap_NonstandardSwaption_underlyingSwap, METH_O, NULL},
	 { "NonstandardSwaption_calibrationBasket", _wrap_NonstandardSwaption_calibrationBasket, METH_VARARGS, NULL},
	 { "NonstandardSwaption_probabilities", _wrap_NonstandardSwaption_probabilities, METH_O, NULL},
	 { "delete_NonstandardSwaption", _wrap_delete_NonstandardSwaption, METH_O, NULL},
	 { "NonstandardSwaption_swigregister", NonstandardSwaption_swigregister, METH_O, NULL},
	 { "NonstandardSwaption_swiginit", NonstandardSwaption_swiginit, METH_VARARGS, NULL},
	 { "new_FloatFloatSwaption", _wrap_new_FloatFloatSwaption, METH_VARARGS, NULL},
	 { "FloatFloatSwaption_underlyingSwap", _wrap_FloatFloatSwaption_underlyingSwap, METH_O, NULL},
	 { "FloatFloatSwaption_calibrationBasket", _wrap_FloatFloatSwaption_calibrationBasket, METH_VARARGS, NULL},
	 { "FloatFloatSwaption_underlyingValue", _wrap_FloatFloatSwaption_underlyingValue, METH_O, NULL},
	 { "FloatFloatSwaption_probabilities", _wrap_FloatFloatSwaption_probabilities, METH_O, NULL},
	 { "delete_FloatFloatSwaption", _wrap_delete_FloatFloatSwaption, METH_O, NULL},
	 { "FloatFloatSwaption_swigregister", FloatFloatSwaption_swigregister, METH_O, NULL},
	 { "FloatFloatSwaption_swiginit", FloatFloatSwaption_swiginit, METH_VARARGS, NULL},
	 { "new_BlackSwaptionEngine", _wrap_new_BlackSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_BlackSwaptionEngine", _wrap_delete_BlackSwaptionEngine, METH_O, NULL},
	 { "BlackSwaptionEngine_swigregister", BlackSwaptionEngine_swigregister, METH_O, NULL},
	 { "BlackSwaptionEngine_swiginit", BlackSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BachelierSwaptionEngine", _wrap_new_BachelierSwaptionEngine, METH_VARARGS, NULL},
	 { "delete_BachelierSwaptionEngine", _wrap_delete_BachelierSwaptionEngine, METH_O, NULL},
	 { "BachelierSwaptionEngine_swigregister", BachelierSwaptionEngine_swigregister, METH_O, NULL},
	 { "BachelierSwaptionEngine_swiginit", BachelierSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "enableTracing", _wrap_enableTracing, METH_NOARGS, NULL},
	 { "disableTracing", _wrap_disableTracing, METH_NOARGS, NULL},
	 { "new_ConstantEstimator", _wrap_new_ConstantEstimator, METH_O, NULL},
	 { "ConstantEstimator_calculate", _wrap_ConstantEstimator_calculate, METH_VARARGS, NULL},
	 { "delete_ConstantEstimator", _wrap_delete_ConstantEstimator, METH_O, NULL},
	 { "ConstantEstimator_swigregister", ConstantEstimator_swigregister, METH_O, NULL},
	 { "ConstantEstimator_swiginit", ConstantEstimator_swiginit, METH_VARARGS, NULL},
	 { "new_ParkinsonSigma", _wrap_new_ParkinsonSigma, METH_O, NULL},
	 { "ParkinsonSigma_calculate", _wrap_ParkinsonSigma_calculate, METH_VARARGS, NULL},
	 { "delete_ParkinsonSigma", _wrap_delete_ParkinsonSigma, METH_O, NULL},
	 { "ParkinsonSigma_swigregister", ParkinsonSigma_swigregister, METH_O, NULL},
	 { "ParkinsonSigma_swiginit", ParkinsonSigma_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma1", _wrap_new_GarmanKlassSigma1, METH_VARARGS, NULL},
	 { "GarmanKlassSigma1_calculate", _wrap_GarmanKlassSigma1_calculate, METH_VARARGS, NULL},
	 { "delete_GarmanKlassSigma1", _wrap_delete_GarmanKlassSigma1, METH_O, NULL},
	 { "GarmanKlassSigma1_swigregister", GarmanKlassSigma1_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma1_swiginit", GarmanKlassSigma1_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma3", _wrap_new_GarmanKlassSigma3, METH_VARARGS, NULL},
	 { "GarmanKlassSigma3_calculate", _wrap_GarmanKlassSigma3_calculate, METH_VARARGS, NULL},
	 { "delete_GarmanKlassSigma3", _wrap_delete_GarmanKlassSigma3, METH_O, NULL},
	 { "GarmanKlassSigma3_swigregister", GarmanKlassSigma3_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma3_swiginit", GarmanKlassSigma3_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma4", _wrap_new_GarmanKlassSigma4, METH_O, NULL},
	 { "GarmanKlassSigma4_calculate", _wrap_GarmanKlassSigma4_calculate, METH_VARARGS, NULL},
	 { "delete_GarmanKlassSigma4", _wrap_delete_GarmanKlassSigma4, METH_O, NULL},
	 { "GarmanKlassSigma4_swigregister", GarmanKlassSigma4_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma4_swiginit", GarmanKlassSigma4_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma5", _wrap_new_GarmanKlassSigma5, METH_O, NULL},
	 { "GarmanKlassSigma5_calculate", _wrap_GarmanKlassSigma5_calculate, METH_VARARGS, NULL},
	 { "delete_GarmanKlassSigma5", _wrap_delete_GarmanKlassSigma5, METH_O, NULL},
	 { "GarmanKlassSigma5_swigregister", GarmanKlassSigma5_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma5_swiginit", GarmanKlassSigma5_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma6", _wrap_new_GarmanKlassSigma6, METH_VARARGS, NULL},
	 { "GarmanKlassSigma6_calculate", _wrap_GarmanKlassSigma6_calculate, METH_VARARGS, NULL},
	 { "delete_GarmanKlassSigma6", _wrap_delete_GarmanKlassSigma6, METH_O, NULL},
	 { "GarmanKlassSigma6_swigregister", GarmanKlassSigma6_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma6_swiginit", GarmanKlassSigma6_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroCurve", _wrap_new_ZeroCurve, METH_VARARGS, NULL},
	 { "ZeroCurve_times", _wrap_ZeroCurve_times, METH_O, NULL},
	 { "ZeroCurve_data", _wrap_ZeroCurve_data, METH_O, NULL},
	 { "ZeroCurve_dates", _wrap_ZeroCurve_dates, METH_O, NULL},
	 { "ZeroCurve_zeroRates", _wrap_ZeroCurve_zeroRates, METH_O, NULL},
	 { "ZeroCurve_nodes", _wrap_ZeroCurve_nodes, METH_O, NULL},
	 { "delete_ZeroCurve", _wrap_delete_ZeroCurve, METH_O, NULL},
	 { "ZeroCurve_swigregister", ZeroCurve_swigregister, METH_O, NULL},
	 { "ZeroCurve_swiginit", ZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_LogLinearZeroCurve", _wrap_new_LogLinearZeroCurve, METH_VARARGS, NULL},
	 { "LogLinearZeroCurve_times", _wrap_LogLinearZeroCurve_times, METH_O, NULL},
	 { "LogLinearZeroCurve_data", _wrap_LogLinearZeroCurve_data, METH_O, NULL},
	 { "LogLinearZeroCurve_dates", _wrap_LogLinearZeroCurve_dates, METH_O, NULL},
	 { "LogLinearZeroCurve_zeroRates", _wrap_LogLinearZeroCurve_zeroRates, METH_O, NULL},
	 { "LogLinearZeroCurve_nodes", _wrap_LogLinearZeroCurve_nodes, METH_O, NULL},
	 { "delete_LogLinearZeroCurve", _wrap_delete_LogLinearZeroCurve, METH_O, NULL},
	 { "LogLinearZeroCurve_swigregister", LogLinearZeroCurve_swigregister, METH_O, NULL},
	 { "LogLinearZeroCurve_swiginit", LogLinearZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_CubicZeroCurve", _wrap_new_CubicZeroCurve, METH_VARARGS, NULL},
	 { "CubicZeroCurve_times", _wrap_CubicZeroCurve_times, METH_O, NULL},
	 { "CubicZeroCurve_data", _wrap_CubicZeroCurve_data, METH_O, NULL},
	 { "CubicZeroCurve_dates", _wrap_CubicZeroCurve_dates, METH_O, NULL},
	 { "CubicZeroCurve_zeroRates", _wrap_CubicZeroCurve_zeroRates, METH_O, NULL},
	 { "CubicZeroCurve_nodes", _wrap_CubicZeroCurve_nodes, METH_O, NULL},
	 { "delete_CubicZeroCurve", _wrap_delete_CubicZeroCurve, METH_O, NULL},
	 { "CubicZeroCurve_swigregister", CubicZeroCurve_swigregister, METH_O, NULL},
	 { "CubicZeroCurve_swiginit", CubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NaturalCubicZeroCurve", _wrap_new_NaturalCubicZeroCurve, METH_VARARGS, NULL},
	 { "NaturalCubicZeroCurve_times", _wrap_NaturalCubicZeroCurve_times, METH_O, NULL},
	 { "NaturalCubicZeroCurve_data", _wrap_NaturalCubicZeroCurve_data, METH_O, NULL},
	 { "NaturalCubicZeroCurve_dates", _wrap_NaturalCubicZeroCurve_dates, METH_O, NULL},
	 { "NaturalCubicZeroCurve_zeroRates", _wrap_NaturalCubicZeroCurve_zeroRates, METH_O, NULL},
	 { "NaturalCubicZeroCurve_nodes", _wrap_NaturalCubicZeroCurve_nodes, METH_O, NULL},
	 { "delete_NaturalCubicZeroCurve", _wrap_delete_NaturalCubicZeroCurve, METH_O, NULL},
	 { "NaturalCubicZeroCurve_swigregister", NaturalCubicZeroCurve_swigregister, METH_O, NULL},
	 { "NaturalCubicZeroCurve_swiginit", NaturalCubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_LogCubicZeroCurve", _wrap_new_LogCubicZeroCurve, METH_VARARGS, NULL},
	 { "LogCubicZeroCurve_times", _wrap_LogCubicZeroCurve_times, METH_O, NULL},
	 { "LogCubicZeroCurve_data", _wrap_LogCubicZeroCurve_data, METH_O, NULL},
	 { "LogCubicZeroCurve_dates", _wrap_LogCubicZeroCurve_dates, METH_O, NULL},
	 { "LogCubicZeroCurve_zeroRates", _wrap_LogCubicZeroCurve_zeroRates, METH_O, NULL},
	 { "LogCubicZeroCurve_nodes", _wrap_LogCubicZeroCurve_nodes, METH_O, NULL},
	 { "delete_LogCubicZeroCurve", _wrap_delete_LogCubicZeroCurve, METH_O, NULL},
	 { "LogCubicZeroCurve_swigregister", LogCubicZeroCurve_swigregister, METH_O, NULL},
	 { "LogCubicZeroCurve_swiginit", LogCubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubicZeroCurve", _wrap_new_MonotonicCubicZeroCurve, METH_VARARGS, NULL},
	 { "MonotonicCubicZeroCurve_times", _wrap_MonotonicCubicZeroCurve_times, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_data", _wrap_MonotonicCubicZeroCurve_data, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_dates", _wrap_MonotonicCubicZeroCurve_dates, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_zeroRates", _wrap_MonotonicCubicZeroCurve_zeroRates, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_nodes", _wrap_MonotonicCubicZeroCurve_nodes, METH_O, NULL},
	 { "delete_MonotonicCubicZeroCurve", _wrap_delete_MonotonicCubicZeroCurve, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_swigregister", MonotonicCubicZeroCurve_swigregister, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_swiginit", MonotonicCubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_CustomRegionTo_p_Region(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Region *)  ((CustomRegion *) 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_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_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_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_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_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_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_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_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_OvernightIndexedCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((OvernightIndexedCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((CappedFlooredCoupon *) x));
}
static void *_p_IborCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((IborCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *) (CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_CmsSpreadCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((CmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *) (CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CmsCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((CmsCoupon *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *) (CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_WiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Wibor *) x));
}
static void *_p_Bbsw1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Euribor365To_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Euribor365 *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_YYEUHICPrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYEUHICPr *) x));
}
static void *_p_EURLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((EURLibor *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixB *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixB *) 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_Bbsw6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw6M *) x));
}
static void *_p_EURLibor3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor3M *) x));
}
static void *_p_Euribor3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3M *) x));
}
static void *_p_Bibor3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor3M *) x));
}
static void *_p_ZACPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((ZACPI *) x));
}
static void *_p_Bkbm1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm1M *) x));
}
static void *_p_EURLibor8MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor8M *) x));
}
static void *_p_Euribor8MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor8M *) x));
}
static void *_p_GBPLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((GBPLibor *) x));
}
static void *_p_YYUKRPIrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUKRPIr *) 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_Bkbm6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm6M *) x));
}
static void *_p_AoniaTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Aonia *) x));
}
static void *_p_FRHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((FRHICP *) 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_EURLiborSWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EuriborSWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((EuriborSW *) x));
}
static void *_p_RoborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Robor *) x));
}
static void *_p_BiborSWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((BiborSW *) x));
}
static void *_p_SoniaTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sonia *) x));
}
static void *_p_BbswTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Bbsw *) x));
}
static void *_p_InterestRateIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *)  ((InterestRateIndex *) x));
}
static void *_p_FedFundsTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((FedFunds *) x));
}
static void *_p_Euribor3WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3W *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_CdorTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Cdor *) x));
}
static void *_p_ShiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Shibor *) x));
}
static void *_p_Bbsw4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw4M *) x));
}
static void *_p_YYUSCPIrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUSCPIr *) x));
}
static void *_p_EURLibor1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1M *) x));
}
static void *_p_Euribor1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1M *) x));
}
static void *_p_Bibor1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1M *) x));
}
static void *_p_EURLibor6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor6M *) x));
}
static void *_p_Euribor6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor6M *) x));
}
static void *_p_Bibor6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor6M *) 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_Bkbm4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm4M *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EuriborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIfrFix *) 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_InflationIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *)  ((InflationIndex *) x));
}
static void *_p_ZeroInflationIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *) ((ZeroInflationIndex *) x));
}
static void *_p_YoYInflationIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *) ((YoYInflationIndex *) x));
}
static void *_p_NZDLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((NZDLibor *) x));
}
static void *_p_ZiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Zibor *) 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_EURLibor11MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor11M *) x));
}
static void *_p_Euribor11MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor11M *) x));
}
static void *_p_DailyTenorLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((DailyTenorLibor *) x));
}
static void *_p_TRLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((TRLibor *) x));
}
static void *_p_EURLibor1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_Euribor1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1Y *) x));
}
static void *_p_Bibor1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1Y *) x));
}
static void *_p_EUHICPXTTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((EUHICPXT *) x));
}
static void *_p_YYEUHICPXTTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYEUHICPXT *) x));
}
static void *_p_CADLiborONTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_GBPLiborONTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_PriborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Pribor *) x));
}
static void *_p_USDLiborONTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_YYUSCPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUSCPI *) x));
}
static void *_p_YYZACPIrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYZACPIr *) x));
}
static void *_p_Bbsw2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw2M *) 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_YYFRHICPrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYFRHICPr *) x));
}
static void *_p_EURLibor4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor4M *) x));
}
static void *_p_Euribor4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor4M *) x));
}
static void *_p_YYEUHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYEUHICP *) x));
}
static void *_p_EURLibor9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor9M *) x));
}
static void *_p_Euribor9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor9M *) x));
}
static void *_p_Bkbm2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bibor9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor9M *) 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_DKKLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((DKKLibor *) x));
}
static void *_p_SEKLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((SEKLibor *) x));
}
static void *_p_EoniaTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Eonia *) x));
}
static void *_p_YYUKRPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUKRPI *) x));
}
static void *_p_SwapIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *) ((SwapIndex *) x));
}
static void *_p_BiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Bibor *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((OvernightIndexedSwapIndex *) x));
}
static void *_p_USCPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((USCPI *) x));
}
static void *_p_CHFLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((CHFLibor *) x));
}
static void *_p_EuriborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Euribor *) x));
}
static void *_p_Bbsw5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw5M *) x));
}
static void *_p_EURLibor2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2M *) x));
}
static void *_p_Euribor2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2M *) x));
}
static void *_p_Bibor2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor2M *) x));
}
static void *_p_TiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Tibor *) x));
}
static void *_p_EURLibor7MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor7M *) x));
}
static void *_p_Euribor7MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor7M *) x));
}
static void *_p_SofrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sofr *) 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_Bkbm5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm5M *) 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_LiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Libor *) 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_UKRPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((UKRPI *) x));
}
static void *_p_YYFRHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYFRHICP *) x));
}
static void *_p_EURLibor2WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2W *) x));
}
static void *_p_Euribor2WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2W *) 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_EUHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((EUHICP *) x));
}
static void *_p_BkbmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Bkbm *) x));
}
static void *_p_Bbsw3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw3M *) 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_JpyLiborSwapIsdaFixAmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_OvernightIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((OvernightIndex *) x));
}
static void *_p_JibarTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Jibar *) x));
}
static void *_p_YYZACPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYZACPI *) x));
}
static void *_p_SwapSpreadIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *) ((SwapSpreadIndex *) x));
}
static void *_p_EURLibor5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor5M *) x));
}
static void *_p_Euribor5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor5M *) 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_Bkbm3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm3M *) x));
}
static void *_p_JPYLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((JPYLibor *) x));
}
static void *_p_IborIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *) ((IborIndex *) x));
}
static void *_p_AUCPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((AUCPI *) 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_JpyLiborSwapIsdaFixPmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_MosprimeTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Mosprime *) x));
}
static void *_p_THBFIXTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((THBFIX *) x));
}
static void *_p_EURLibor10MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor10M *) x));
}
static void *_p_Euribor10MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor10M *) x));
}
static void *_p_NzocrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Nzocr *) x));
}
static void *_p_CADLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((CADLibor *) x));
}
static void *_p_AUDLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((AUDLibor *) x));
}
static void *_p_USDLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((USDLibor *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_FaceValueClaimTo_p_Claim(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Claim *)  ((FaceValueClaim *) x));
}
static void *_p_FaceValueAccrualClaimTo_p_Claim(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Claim *)  ((FaceValueAccrualClaim *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_CappedFlooredCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CappedFlooredCoupon *)  ((CappedFlooredIborCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_CappedFlooredCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CappedFlooredCoupon *)  ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_CappedFlooredCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CappedFlooredCoupon *)  ((CappedFlooredCmsCoupon *) x));
}
static void *_p_OvernightIndexedCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((OvernightIndexedCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((CappedFlooredCoupon *) x));
}
static void *_p_IborCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((IborCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_CmsSpreadCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((CmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_InflationCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *)  ((InflationCoupon *) 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_CmsCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((CmsCoupon *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CPICouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (InflationCoupon *) ((CPICoupon *) x));
}
static void *_p_CPICouponTo_p_InflationCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationCoupon *)  ((CPICoupon *) x));
}
static void *_p_WiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Wibor *) x));
}
static void *_p_Bbsw1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Euribor365To_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Euribor365 *) x));
}
static void *_p_EURLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((EURLibor *) x));
}
static void *_p_Euribor365_1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_1Y *) x));
}
static void *_p_Bbsw6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw6M *) x));
}
static void *_p_EURLibor3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor3M *) x));
}
static void *_p_Euribor3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor3M *) x));
}
static void *_p_Bibor3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor3M *) x));
}
static void *_p_Bkbm1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm1M *) x));
}
static void *_p_EURLibor8MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor8M *) x));
}
static void *_p_Euribor8MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor8M *) x));
}
static void *_p_GBPLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((GBPLibor *) x));
}
static void *_p_Euribor365_4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_4M *) x));
}
static void *_p_Bkbm6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm6M *) x));
}
static void *_p_AoniaTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Aonia *) x));
}
static void *_p_Euribor365_9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_9M *) x));
}
static void *_p_EURLiborSWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EuriborSWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((EuriborSW *) x));
}
static void *_p_RoborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Robor *) x));
}
static void *_p_BiborSWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((BiborSW *) x));
}
static void *_p_SoniaTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Sonia *) x));
}
static void *_p_BbswTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Bbsw *) x));
}
static void *_p_FedFundsTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((FedFunds *) x));
}
static void *_p_Euribor3WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor3W *) x));
}
static void *_p_CdorTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Cdor *) x));
}
static void *_p_ShiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Shibor *) x));
}
static void *_p_Bbsw4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw4M *) x));
}
static void *_p_EURLibor1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor1M *) x));
}
static void *_p_Euribor1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor1M *) x));
}
static void *_p_Bibor1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor1M *) x));
}
static void *_p_EURLibor6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor6M *) x));
}
static void *_p_Euribor6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor6M *) x));
}
static void *_p_Bibor6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor6M *) x));
}
static void *_p_Euribor365_2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_Bkbm4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm4M *) x));
}
static void *_p_Euribor365_7MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_7M *) x));
}
static void *_p_NZDLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((NZDLibor *) x));
}
static void *_p_ZiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Zibor *) x));
}
static void *_p_Euribor365_10MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_10M *) x));
}
static void *_p_EURLibor11MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor11M *) x));
}
static void *_p_Euribor11MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor11M *) x));
}
static void *_p_DailyTenorLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((DailyTenorLibor *) x));
}
static void *_p_TRLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((TRLibor *) x));
}
static void *_p_EURLibor1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_Euribor1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor1Y *) x));
}
static void *_p_Bibor1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor1Y *) x));
}
static void *_p_GBPLiborONTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_CADLiborONTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_PriborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Pribor *) x));
}
static void *_p_USDLiborONTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_Bbsw2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw2M *) x));
}
static void *_p_Euribor365_2WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_2W *) x));
}
static void *_p_EURLibor4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor4M *) x));
}
static void *_p_Euribor4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor4M *) x));
}
static void *_p_EURLibor9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor9M *) x));
}
static void *_p_Euribor9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor9M *) x));
}
static void *_p_Bkbm2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bibor9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor9M *) x));
}
static void *_p_Euribor365_5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_5M *) x));
}
static void *_p_DKKLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((DKKLibor *) x));
}
static void *_p_SEKLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((SEKLibor *) x));
}
static void *_p_EoniaTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Eonia *) x));
}
static void *_p_BiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Bibor *) x));
}
static void *_p_CHFLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((CHFLibor *) x));
}
static void *_p_EuriborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Euribor *) x));
}
static void *_p_Bbsw5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw5M *) x));
}
static void *_p_EURLibor2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor2M *) x));
}
static void *_p_Euribor2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor2M *) x));
}
static void *_p_Bibor2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor2M *) x));
}
static void *_p_TiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Tibor *) x));
}
static void *_p_EURLibor7MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor7M *) x));
}
static void *_p_Euribor7MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor7M *) x));
}
static void *_p_SofrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Sofr *) x));
}
static void *_p_Euribor365_3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_3M *) x));
}
static void *_p_Bkbm5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm5M *) x));
}
static void *_p_Euribor365_8MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_8M *) x));
}
static void *_p_LiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Libor *) x));
}
static void *_p_Euribor365_11MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_11M *) x));
}
static void *_p_EURLibor2WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor2W *) x));
}
static void *_p_Euribor2WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor2W *) x));
}
static void *_p_Euribor365_SWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_SW *) x));
}
static void *_p_BkbmTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Bkbm *) x));
}
static void *_p_Bbsw3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw3M *) x));
}
static void *_p_Euribor365_3WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_3W *) x));
}
static void *_p_OvernightIndexTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((OvernightIndex *) x));
}
static void *_p_JibarTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Jibar *) x));
}
static void *_p_EURLibor5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor5M *) x));
}
static void *_p_Euribor5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor5M *) x));
}
static void *_p_JPYLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((JPYLibor *) x));
}
static void *_p_Euribor365_1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_1M *) x));
}
static void *_p_Bkbm3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm3M *) x));
}
static void *_p_Euribor365_6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_6M *) x));
}
static void *_p_MosprimeTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Mosprime *) x));
}
static void *_p_THBFIXTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((THBFIX *) x));
}
static void *_p_EURLibor10MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor10M *) x));
}
static void *_p_Euribor10MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor10M *) x));
}
static void *_p_NzocrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Nzocr *) x));
}
static void *_p_CADLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((CADLibor *) x));
}
static void *_p_AUDLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((AUDLibor *) x));
}
static void *_p_USDLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((USDLibor *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_SwaptionVolCube2_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwaptionVolCube2 > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_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< WulinYongDoubleBarrierEngine > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_WulinYongDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< WulinYongDoubleBarrierEngine > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_FDDividendAmericanEngineT_CrankNicolson_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< FDDividendAmericanEngine< CrankNicolson > > *)x);
}
static void *_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_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< FDDividendEuropeanEngine< CrankNicolson > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_InterpolatedPiecewiseZeroSpreadedTermStructureT_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< InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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< InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_FDShoutEngineT_CrankNicolson_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< FDShoutEngine< CrankNicolson > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_FDAmericanEngineT_CrankNicolson_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< FDAmericanEngine< CrankNicolson > > *)x);
}
static void *_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_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< FDEuropeanEngine< CrankNicolson > > *)x);
}
static void *_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_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< FDBermudanEngine< CrankNicolson > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_SwaptionVolCube1_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwaptionVolCube1 > *)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_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_FRHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((FRHICP *) x));
}
static void *_p_YYUKRPIrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUKRPIr *) x));
}
static void *_p_YYEUHICPXTTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYEUHICPXT *) x));
}
static void *_p_EUHICPXTTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((EUHICPXT *) x));
}
static void *_p_YoYInflationIndexTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *)  ((YoYInflationIndex *) x));
}
static void *_p_ZeroInflationIndexTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *)  ((ZeroInflationIndex *) x));
}
static void *_p_YYUSCPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUSCPI *) x));
}
static void *_p_YYZACPIrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYZACPIr *) x));
}
static void *_p_YYEUHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYEUHICP *) x));
}
static void *_p_YYZACPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYZACPI *) x));
}
static void *_p_YYFRHICPrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYFRHICPr *) x));
}
static void *_p_USCPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((USCPI *) x));
}
static void *_p_YYUKRPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUKRPI *) x));
}
static void *_p_YYEUHICPrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYEUHICPr *) x));
}
static void *_p_EUHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((EUHICP *) x));
}
static void *_p_YYFRHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYFRHICP *) x));
}
static void *_p_ZACPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((ZACPI *) x));
}
static void *_p_YYUSCPIrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUSCPIr *) x));
}
static void *_p_AUCPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((AUCPI *) x));
}
static void *_p_UKRPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((UKRPI *) x));
}
static void *_p_ZACPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((ZACPI *) x));
}
static void *_p_FRHICPTo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((FRHICP *) x));
}
static void *_p_AUCPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((AUCPI *) x));
}
static void *_p_USCPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((USCPI *) 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_UKRPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((UKRPI *) x));
}
static void *_p_YYEUHICPTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYEUHICP *) 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_YYUKRPITo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYUKRPI *) x));
}
static void *_p_YYZACPIrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYZACPIr *) x));
}
static void *_p_YYZACPITo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYZACPI *) x));
}
static void *_p_YYFRHICPTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYFRHICP *) x));
}
static void *_p_YYUKRPIrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYUKRPIr *) 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_YYFRHICPrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYFRHICPr *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_ForwardVanillaOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ForwardVanillaOption *)  ((QuantoForwardVanillaOption *) x));
}
static void *_p_EuropeanOptionTo_p_VanillaOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VanillaOption *)  ((EuropeanOption *) 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_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_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_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_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_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_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_CallableZeroCouponBondTo_p_CallableBond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CallableBond *)  ((CallableZeroCouponBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_CallableBond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CallableBond *)  ((CallableFixedRateBond *) x));
}
static void *_p_QuantLib__ITLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ITLCurrency *) x));
}
static void *_p_QuantLib__ISKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ISKCurrency *) x));
}
static void *_p_QuantLib__IRRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::IRRCurrency *) x));
}
static void *_p_QuantLib__IQDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::IQDCurrency *) x));
}
static void *_p_QuantLib__INRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::INRCurrency *) x));
}
static void *_p_QuantLib__ILSCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ILSCurrency *) 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__HUFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::HUFCurrency *) x));
}
static void *_p_QuantLib__HKDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::HKDCurrency *) x));
}
static void *_p_QuantLib__GRDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::GRDCurrency *) x));
}
static void *_p_QuantLib__GBPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::GBPCurrency *) x));
}
static void *_p_QuantLib__FRFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::FRFCurrency *) x));
}
static void *_p_QuantLib__FIMCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::FIMCurrency *) x));
}
static void *_p_QuantLib__EURCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::EURCurrency *) x));
}
static void *_p_QuantLib__ESPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ESPCurrency *) x));
}
static void *_p_QuantLib__EEKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::EEKCurrency *) x));
}
static void *_p_QuantLib__DKKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::DKKCurrency *) x));
}
static void *_p_QuantLib__DEMCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::DEMCurrency *) x));
}
static void *_p_QuantLib__CZKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CZKCurrency *) 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__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__BRLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BRLCurrency *) 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__CLPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CLPCurrency *) 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__CYPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CYPCurrency *) x));
}
static void *_p_QuantLib__JPYCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::JPYCurrency *) 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__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__MTLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MTLCurrency *) x));
}
static void *_p_QuantLib__MXNCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MXNCurrency *) x));
}
static void *_p_QuantLib__MYRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MYRCurrency *) 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__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__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__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__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__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__USDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::USDCurrency *) 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__ZARCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ZARCurrency *) x));
}
static void *_p_SpreadOptionTo_p_MultiAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MultiAssetOption *)  ((SpreadOption *) 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_QuantoDoubleBarrierOptionTo_p_DoubleBarrierOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DoubleBarrierOption *)  ((QuantoDoubleBarrierOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_BarrierOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BarrierOption *)  ((DividendBarrierOption *) x));
}
static void *_p_EuropeanOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_BarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((BarrierOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ContinuousAveragingAsianOption *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((DiscreteAveragingAsianOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((DoubleBarrierOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_VanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((VanillaOption *) x));
}
static void *_p_ForwardVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((QuantoVanillaOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((DividendVanillaOption *) x));
}
static void *_p_VanillaSwingOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((VanillaSwingOption *) x));
}
static void *_p_SwaptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((Swaption *) x));
}
static void *_p_DividendVanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((DividendVanillaOption *) 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_ForwardVanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ForwardVanillaOption *) 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_HimalayaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_CdsOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((CdsOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_BarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_MultiAssetOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((MultiAssetOption *) x));
}
static void *_p_EuropeanOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_OneAssetOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((OneAssetOption *) x));
}
static void *_p_SpreadOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_BasketOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_EverestOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((EverestOption *) 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_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_YoYOptionletVolatilitySurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletVolatilitySurface *)  ((InterpolatedYoYOptionletVolatilityCurve< Linear > *) x));
}
static void *_p_ConstantYoYOptionletVolatilityTo_p_YoYOptionletVolatilitySurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletVolatilitySurface *)  ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_YoYOptionletVolatilitySurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletVolatilitySurface *)  ((KInterpolatedYoYOptionletVolatilitySurface< Linear > *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_LocalVolSurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolSurface *)  ((NoExceptLocalVolSurface *) x));
}
static void *_p_YoYInflationCapFloorTermPriceSurfaceTo_p_YoYCapFloorTermPriceSurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYCapFloorTermPriceSurface *)  ((YoYInflationCapFloorTermPriceSurface *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_BatesProcessTo_p_HestonProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((HestonProcess *)  ((BatesProcess *) x));
}
static void *_p_BlackScholesProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((BlackScholesProcess *) x));
}
static void *_p_BlackScholesMertonProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((BlackScholesMertonProcess *) x));
}
static void *_p_BlackProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((BlackProcess *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((GarmanKohlagenProcess *) x));
}
static void *_p_StochasticProcessArrayTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((StochasticProcessArray *) x));
}
static void *_p_StochasticProcess1DTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((StochasticProcess1D *) 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_BatesProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (HestonProcess *) ((BatesProcess *) x));
}
static void *_p_HestonProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((HestonProcess *) x));
}
static void *_p_VarianceGammaProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((VarianceGammaProcess *) x));
}
static void *_p_GeometricBrownianMotionProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((GeometricBrownianMotionProcess *) x));
}
static void *_p_Merton76ProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((Merton76Process *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((GarmanKohlagenProcess *) 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_GeneralizedBlackScholesProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((GeneralizedBlackScholesProcess *) x));
}
static void *_p_G2ProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((G2Process *) x));
}
static void *_p_G2ForwardProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((G2ForwardProcess *) x));
}
static void *_p_GsrProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((GsrProcess *) x));
}
static void *_p_OrnsteinUhlenbeckProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((OrnsteinUhlenbeckProcess *) x));
}
static void *_p_ExtendedOrnsteinUhlenbeckProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((ExtendedOrnsteinUhlenbeckProcess *) x));
}
static void *_p_ExtOUWithJumpsProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((ExtOUWithJumpsProcess *) x));
}
static void *_p_KlugeExtOUProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((KlugeExtOUProcess *) x));
}
static void *_p_GJRGARCHProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((GJRGARCHProcess *) x));
}
static void *_p_HestonSLVProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((HestonSLVProcess *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_RelinkableHandleT_YoYOptionletVolatilitySurface_tTo_p_HandleT_YoYOptionletVolatilitySurface_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< YoYOptionletVolatilitySurface > *)  ((RelinkableHandle< YoYOptionletVolatilitySurface > *) x));
}
static void *_p_YoYOptionletHelperTo_p_BootstrapHelperT_YoYOptionletVolatilitySurface_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BootstrapHelper< YoYOptionletVolatilitySurface > *)  ((YoYOptionletHelper *) 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_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_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_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_GeneralizedBlackScholesProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((GeneralizedBlackScholesProcess *) x));
}
static void *_p_BlackScholesProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((BlackScholesProcess *) x));
}
static void *_p_BlackScholesMertonProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((BlackScholesMertonProcess *) x));
}
static void *_p_BlackProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((BlackProcess *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((GarmanKohlagenProcess *) x));
}
static void *_p_Merton76ProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((Merton76Process *) x));
}
static void *_p_GeometricBrownianMotionProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((GeometricBrownianMotionProcess *) x));
}
static void *_p_VarianceGammaProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((VarianceGammaProcess *) x));
}
static void *_p_HullWhiteProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((HullWhiteProcess *) x));
}
static void *_p_HullWhiteForwardProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((HullWhiteForwardProcess *) x));
}
static void *_p_GsrProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((GsrProcess *) x));
}
static void *_p_OrnsteinUhlenbeckProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((OrnsteinUhlenbeckProcess *) x));
}
static void *_p_ExtendedOrnsteinUhlenbeckProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((ExtendedOrnsteinUhlenbeckProcess *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_RelinkableHandleT_CalibratedModel_tTo_p_HandleT_CalibratedModel_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< CalibratedModel > *)  ((RelinkableHandle< CalibratedModel > *) 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_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_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_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_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_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_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_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_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_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_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_NeumannBCTo_p_DefaultBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultBoundaryCondition *)  ((NeumannBC *) x));
}
static void *_p_DirichletBCTo_p_DefaultBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultBoundaryCondition *)  ((DirichletBC *) x));
}
static void *_p_FdmLogInnerValueTo_p_FdmCellAveragingInnerValue(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmCellAveragingInnerValue *)  ((FdmLogInnerValue *) x));
}
static void *_p_ForwardRateAgreementTo_p_Forward(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Forward *)  ((ForwardRateAgreement *) x));
}
static void *_p_FixedRateBondForwardTo_p_Forward(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Forward *)  ((FixedRateBondForward *) x));
}
static void *_p_BiborSWTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((BiborSW *) x));
}
static void *_p_Bibor6MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor6M *) x));
}
static void *_p_Bibor1MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor1M *) x));
}
static void *_p_Bibor3MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor3M *) x));
}
static void *_p_Bibor2MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor2M *) x));
}
static void *_p_Bibor9MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor9M *) x));
}
static void *_p_Bibor1YTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor1Y *) x));
}
static void *_p_ext__shared_ptrT_SwaptionVolCube2_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< SwaptionVolCube2 > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolCube1_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< SwaptionVolCube1 > *)x);
}
static void *_p_EuropeanExerciseTo_p_Exercise(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Exercise *)  ((EuropeanExercise *) 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_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_SwaptionVolCube1To_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *) (SwaptionVolatilityCube *) ((SwaptionVolCube1 *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *)  ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolCube2To_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *) (SwaptionVolatilityCube *) ((SwaptionVolCube2 *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *)  ((SwaptionVolatilityMatrix *) 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_SwaptionVolCube2_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< SwaptionVolCube2 > *)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_SwaptionVolCube1_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< SwaptionVolCube1 > *)x);
}
static void *_p_Euribor365_1MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_1M *) x));
}
static void *_p_Euribor365_9MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_9M *) x));
}
static void *_p_Euribor365_11MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_11M *) x));
}
static void *_p_Euribor365_10MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_10M *) x));
}
static void *_p_Euribor365_8MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_8M *) x));
}
static void *_p_Euribor365_7MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_7M *) x));
}
static void *_p_Euribor365_3WTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_3W *) x));
}
static void *_p_Euribor365_6MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_6M *) x));
}
static void *_p_Euribor365_2WTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_2W *) x));
}
static void *_p_Euribor365_5MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_5M *) x));
}
static void *_p_Euribor365_SWTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_SW *) x));
}
static void *_p_Euribor365_4MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_4M *) x));
}
static void *_p_Euribor365_1YTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_1Y *) x));
}
static void *_p_Euribor365_3MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_3M *) x));
}
static void *_p_Euribor365_2MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_2M *) x));
}
static void *_p_SoftCallabilityTo_p_Callability(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Callability *)  ((SoftCallability *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_DividendTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((Dividend *) x));
}
static void *_p_FixedDividendTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Dividend *) ((FixedDividend *) x));
}
static void *_p_FractionalDividendTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Dividend *) ((FractionalDividend *) x));
}
static void *_p_AmortizingPaymentTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((AmortizingPayment *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CmsCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((CmsCoupon *) x));
}
static void *_p_FloatingRateCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *) ((FloatingRateCoupon *) x));
}
static void *_p_FixedRateCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *) ((FixedRateCoupon *) x));
}
static void *_p_CPICouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(InflationCoupon *) ((CPICoupon *) x));
}
static void *_p_RedemptionTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((Redemption *) x));
}
static void *_p_CmsSpreadCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((CmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_IborCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((IborCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((CappedFlooredCoupon *) x));
}
static void *_p_OvernightIndexedCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((OvernightIndexedCoupon *) x));
}
static void *_p_CouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((Coupon *) x));
}
static void *_p_IndexedCashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((IndexedCashFlow *) x));
}
static void *_p_SimpleCashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((SimpleCashFlow *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_InflationCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *) ((InflationCoupon *) x));
}
static void *_p_DPlusDMinusTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DPlusDMinus *) x));
}
static void *_p_DPlusTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DPlus *) x));
}
static void *_p_DZeroTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DZero *) x));
}
static void *_p_DMinusTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DMinus *) x));
}
static void *_p_Bkbm3MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm3M *) x));
}
static void *_p_Bkbm5MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm5M *) x));
}
static void *_p_Bkbm2MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm2M *) x));
}
static void *_p_Bkbm4MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm4M *) x));
}
static void *_p_Bkbm6MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm6M *) x));
}
static void *_p_Bkbm1MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm1M *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_PlainVanillaPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((PlainVanillaPayoff *) x));
}
static void *_p_PercentageStrikePayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((PercentageStrikePayoff *) x));
}
static void *_p_CashOrNothingPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((CashOrNothingPayoff *) x));
}
static void *_p_AssetOrNothingPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((AssetOrNothingPayoff *) x));
}
static void *_p_SuperSharePayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((SuperSharePayoff *) x));
}
static void *_p_GapPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((GapPayoff *) x));
}
static void *_p_VanillaForwardPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((VanillaForwardPayoff *) x));
}
static void *_p_StrikedTypePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *)  ((StrikedTypePayoff *) x));
}
static void *_p_PlainVanillaPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((PlainVanillaPayoff *) x));
}
static void *_p_PercentageStrikePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((PercentageStrikePayoff *) x));
}
static void *_p_CashOrNothingPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((CashOrNothingPayoff *) x));
}
static void *_p_AssetOrNothingPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((AssetOrNothingPayoff *) x));
}
static void *_p_SuperSharePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((SuperSharePayoff *) x));
}
static void *_p_GapPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((GapPayoff *) x));
}
static void *_p_VanillaForwardPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((VanillaForwardPayoff *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_HullWhiteTo_p_Vasicek(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Vasicek *)  ((HullWhite *) x));
}
static void *_p_SwaptionVolCube1To_p_SwaptionVolatilityCube(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityCube *)  ((SwaptionVolCube1 *) x));
}
static void *_p_SwaptionVolCube2To_p_SwaptionVolatilityCube(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityCube *)  ((SwaptionVolCube2 *) x));
}
static void *_p_GsrTo_p_TermStructureConsistentModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructureConsistentModel *) (Gaussian1dModel *) ((Gsr *) x));
}
static void *_p_Gaussian1dModelTo_p_TermStructureConsistentModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructureConsistentModel *)  ((Gaussian1dModel *) x));
}
static void *_p_MarkovFunctionalTo_p_TermStructureConsistentModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructureConsistentModel *) (Gaussian1dModel *) ((MarkovFunctional *) 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_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_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_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_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_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_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_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_MinBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((MinBasketPayoff *) x));
}
static void *_p_MaxBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((MaxBasketPayoff *) x));
}
static void *_p_AverageBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((AverageBasketPayoff *) x));
}
static void *_p_SpreadBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((SpreadBasketPayoff *) x));
}
static void *_p_SuperSharePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((SuperSharePayoff *) x));
}
static void *_p_AssetOrNothingPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((AssetOrNothingPayoff *) x));
}
static void *_p_CashOrNothingPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((CashOrNothingPayoff *) 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_StrikedTypePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *) ((StrikedTypePayoff *) x));
}
static void *_p_TypePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *)  ((TypePayoff *) x));
}
static void *_p_SpreadBasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (BasketPayoff *) ((SpreadBasketPayoff *) x));
}
static void *_p_AverageBasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (BasketPayoff *) ((AverageBasketPayoff *) 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_BasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *)  ((BasketPayoff *) x));
}
static void *_p_VanillaForwardPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((VanillaForwardPayoff *) x));
}
static void *_p_GapPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((GapPayoff *) 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_EuriborSWTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((EuriborSW *) x));
}
static void *_p_Euribor4MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor4M *) x));
}
static void *_p_Euribor1YTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor1Y *) x));
}
static void *_p_Euribor3MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor3M *) x));
}
static void *_p_Euribor2MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor2M *) 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_Euribor10MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor10M *) x));
}
static void *_p_Euribor9MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor9M *) x));
}
static void *_p_Euribor8MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor8M *) x));
}
static void *_p_Euribor7MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor7M *) x));
}
static void *_p_Euribor3WTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor3W *) x));
}
static void *_p_Euribor6MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor6M *) x));
}
static void *_p_Euribor2WTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor2W *) x));
}
static void *_p_Euribor5MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor5M *) x));
}
static void *_p_BatesModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (HestonModel *) ((BatesModel *) x));
}
static void *_p_GJRGARCHModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((GJRGARCHModel *) x));
}
static void *_p_ShortRateModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((ShortRateModel *) x));
}
static void *_p_OneFactorAffineModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((OneFactorAffineModel *) x));
}
static void *_p_BlackKarasinskiTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((BlackKarasinski *) x));
}
static void *_p_VasicekTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *)(OneFactorAffineModel *) ((Vasicek *) x));
}
static void *_p_HestonModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((HestonModel *) x));
}
static void *_p_PiecewiseTimeDependentHestonModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((PiecewiseTimeDependentHestonModel *) 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_HullWhiteTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *)(OneFactorAffineModel *)(Vasicek *) ((HullWhite *) 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_InterpolatedYoYOptionletStripperT_Linear_tTo_p_YoYOptionletStripper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletStripper *)  ((InterpolatedYoYOptionletStripper< Linear > *) 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_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_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_CeilingTruncationTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((CeilingTruncation *) 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_DownRoundingTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((DownRounding *) x));
}
static void *_p_ClosestRoundingTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((ClosestRounding *) 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_Quote_tTo_p_HandleT_Quote_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< Quote > *)  ((RelinkableHandle< Quote > *) 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_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_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_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_EverestOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((EverestOption *) x));
}
static void *_p_BasketOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_SpreadOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_OptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Option *) x));
}
static void *_p_OneAssetOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((OneAssetOption *) x));
}
static void *_p_EuropeanOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_MultiAssetOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((MultiAssetOption *) x));
}
static void *_p_BarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_AssetSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((AssetSwap *) x));
}
static void *_p_OvernightIndexedSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((OvernightIndexedSwap *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((YearOnYearInflationSwap *) x));
}
static void *_p_ZeroCouponInflationSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((ZeroCouponInflationSwap *) x));
}
static void *_p_CapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (CapFloor *) ((Cap *) x));
}
static void *_p_VanillaSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((VanillaSwap *) x));
}
static void *_p_YoYInflationFloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (YoYInflationCapFloor *) ((YoYInflationFloor *) x));
}
static void *_p_YoYInflationCapFloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((YoYInflationCapFloor *) x));
}
static void *_p_CapFloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((CapFloor *) x));
}
static void *_p_HimalayaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_VanillaSwingOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((VanillaSwingOption *) x));
}
static void *_p_VanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((VanillaOption *) x));
}
static void *_p_ForwardVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((QuantoVanillaOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((DividendVanillaOption *) x));
}
static void *_p_CdsOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((CdsOption *) x));
}
static void *_p_ForwardRateAgreementTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Forward *) ((ForwardRateAgreement *) x));
}
static void *_p_ZeroCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ZeroCouponBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *)(CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ConvertibleZeroCouponBond *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ConvertibleFixedCouponBond *) x));
}
static void *_p_SwaptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((Swaption *) x));
}
static void *_p_NonstandardSwaptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((NonstandardSwaption *) x));
}
static void *_p_FloatFloatSwaptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((FloatFloatSwaption *) x));
}
static void *_p_CompositeInstrumentTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((CompositeInstrument *) x));
}
static void *_p_StockTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Stock *) x));
}
static void *_p_FloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (CapFloor *) ((Floor *) x));
}
static void *_p_YoYInflationCollarTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (YoYInflationCapFloor *) ((YoYInflationCollar *) x));
}
static void *_p_CollarTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (CapFloor *) ((Collar *) x));
}
static void *_p_YoYInflationCapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (YoYInflationCapFloor *) ((YoYInflationCap *) x));
}
static void *_p_CallableBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((CallableBond *) x));
}
static void *_p_FixedRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((FixedRateBond *) 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_FloatingRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((FloatingRateBond *) x));
}
static void *_p_CmsRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((CmsRateBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *)(CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ConvertibleFloatingRateBond *) x));
}
static void *_p_NonstandardSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((NonstandardSwap *) x));
}
static void *_p_BondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Bond *) x));
}
static void *_p_CreditDefaultSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((CreditDefaultSwap *) x));
}
static void *_p_ForwardTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Forward *) x));
}
static void *_p_FixedRateBondForwardTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Forward *) ((FixedRateBondForward *) x));
}
static void *_p_FloatFloatSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((FloatFloatSwap *) x));
}
static void *_p_SwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Swap *) 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_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_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_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_SofrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Sofr *) x));
}
static void *_p_AoniaTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Aonia *) x));
}
static void *_p_EoniaTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Eonia *) x));
}
static void *_p_SoniaTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Sonia *) x));
}
static void *_p_NzocrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Nzocr *) x));
}
static void *_p_FedFundsTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((FedFunds *) 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_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_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_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_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_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_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_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_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_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_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_Fdm2dBlackScholesOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((Fdm2dBlackScholesOp *) x));
}
static void *_p_FdmBlackScholesOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmBlackScholesOp *) 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_FdmLocalVolFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmLocalVolFwdOp *) x));
}
static void *_p_FdmLinearOpCompositeProxyTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmLinearOpCompositeProxy *) x));
}
static void *_p_TripleBandLinearOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((TripleBandLinearOp *) x));
}
static void *_p_NinePointLinearOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((NinePointLinearOp *) x));
}
static void *_p_FdmHullWhiteOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHullWhiteOp *) x));
}
static void *_p_FdmHestonHullWhiteOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHestonHullWhiteOp *) x));
}
static void *_p_FdmLinearOpCompositeTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((FdmLinearOpComposite *) x));
}
static void *_p_FdmSabrOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmSabrOp *) x));
}
static void *_p_FdmHestonOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHestonOp *) x));
}
static void *_p_FdmHestonFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHestonFwdOp *) x));
}
static void *_p_FdmCEVOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmCEVOp *) x));
}
static void *_p_FdmG2OpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmG2Op *) x));
}
static void *_p_FirstDerivativeOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (TripleBandLinearOp *) ((FirstDerivativeOp *) 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_NthOrderDerivativeOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((NthOrderDerivativeOp *) x));
}
static void *_p_FdmBatesOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmBatesOp *) x));
}
static void *_p_FdmOrnsteinUhlenbeckOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmOrnsteinUhlenbeckOp *) x));
}
static void *_p_FdmDupire1dOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmDupire1dOp *) x));
}
static void *_p_FdmBlackScholesFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmBlackScholesFwdOp *) 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_SecondOrderMixedDerivativeOpTo_p_NinePointLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((NinePointLinearOp *)  ((SecondOrderMixedDerivativeOp *) 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_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_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_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_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_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_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_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_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_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_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_JpyLiborSwapIsdaFixPmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EuriborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EurLiborSwapIfrFix *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((OvernightIndexedSwapIndex *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EuriborSwapIsdaFixB *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_YoYInflationCollarTo_p_YoYInflationCapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCapFloor *)  ((YoYInflationCollar *) x));
}
static void *_p_YoYInflationCapTo_p_YoYInflationCapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCapFloor *)  ((YoYInflationCap *) x));
}
static void *_p_YoYInflationFloorTo_p_YoYInflationCapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCapFloor *)  ((YoYInflationFloor *) x));
}
static void *_p_CollarTo_p_CapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloor *)  ((Collar *) x));
}
static void *_p_CapTo_p_CapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloor *)  ((Cap *) x));
}
static void *_p_FloorTo_p_CapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloor *)  ((Floor *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_ZeroCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ZeroCouponBond *) x));
}
static void *_p_CallableBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((CallableBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *) (CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ConvertibleZeroCouponBond *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ConvertibleFixedCouponBond *) x));
}
static void *_p_FixedRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((FixedRateBond *) 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_FloatingRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((FloatingRateBond *) x));
}
static void *_p_CmsRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((CmsRateBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *) (CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_CPIBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((CPIBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ConvertibleFloatingRateBond *) 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_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_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_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_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_FdmMesherCompositeTo_p_FdmMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmMesher *)  ((FdmMesherComposite *) x));
}
static void *_p_OptionletStripper1To_p_StrippedOptionletBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrippedOptionletBase *)  ((OptionletStripper1 *) x));
}
static void *_p_AssetSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((AssetSwap *) 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_ZeroCouponInflationSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((ZeroCouponInflationSwap *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((YearOnYearInflationSwap *) x));
}
static void *_p_NonstandardSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((NonstandardSwap *) x));
}
static void *_p_CPISwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((CPISwap *) x));
}
static void *_p_FloatFloatSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((FloatFloatSwap *) 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_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_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_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_OneFactorAffineModelTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((OneFactorAffineModel *) x));
}
static void *_p_BlackKarasinskiTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((BlackKarasinski *) x));
}
static void *_p_VasicekTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *) (OneFactorAffineModel *) ((Vasicek *) 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_VasicekTo_p_OneFactorAffineModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneFactorAffineModel *)  ((Vasicek *) x));
}
static void *_p_HullWhiteTo_p_OneFactorAffineModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneFactorAffineModel *) (Vasicek *) ((HullWhite *) 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_RiskStatisticsTo_p_Statistics(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Statistics *)  ((RiskStatistics *) 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_FdmLogInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *) (FdmCellAveragingInnerValue *) ((FdmLogInnerValue *) x));
}
static void *_p_FdmLogBasketInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmLogBasketInnerValue *) x));
}
static void *_p_FdmZeroInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmZeroInnerValue *) x));
}
static void *_p_FdmAffineModelSwapInnerValueT_G2_tTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmAffineModelSwapInnerValue< G2 > *) x));
}
static void *_p_FdmInnerValueCalculatorProxyTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmInnerValueCalculatorProxy *) 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_FdmSnapshotConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmSnapshotCondition *) 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_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_FdmStepConditionCompositeTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmStepConditionComposite *) x));
}
static void *_p_FdmDividendHandlerTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmDividendHandler *) x));
}
static void *_p_FdmStepConditionProxyTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmStepConditionProxy *) 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_FdmCEV1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmCEV1dMesher *) x));
}
static void *_p_FdmSimpleProcess1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmSimpleProcess1dMesher *) x));
}
static void *_p_Uniform1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Uniform1dMesher *) x));
}
static void *_p_Predefined1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Predefined1dMesher *) x));
}
static void *_p_Glued1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Glued1dMesher *) x));
}
static void *_p_FdmBlackScholesMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmBlackScholesMesher *) x));
}
static void *_p_FdmHestonVarianceMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmHestonVarianceMesher *) x));
}
static void *_p_FdmHestonLocalVolatilityVarianceMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmHestonLocalVolatilityVarianceMesher *) x));
}
static void *_p_BinomialVanillaEngineT_CoxRossRubinstein_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< CoxRossRubinstein > *) x));
}
static void *_p_BinomialConvertibleEngineT_CoxRossRubinstein_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< CoxRossRubinstein > *) x));
}
static void *_p_FFTVarianceGammaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FFTVarianceGammaEngine *) x));
}
static void *_p_VarianceGammaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VarianceGammaEngine *) x));
}
static void *_p_FdHestonRebateEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonRebateEngine *) x));
}
static void *_p_FdBlackScholesRebateEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesRebateEngine *) x));
}
static void *_p_FdSabrVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdSabrVanillaEngine *) x));
}
static void *_p_FdCEVVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdCEVVanillaEngine *) x));
}
static void *_p_FdHestonVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonVanillaEngine *) x));
}
static void *_p_FdBatesVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBatesVanillaEngine *) x));
}
static void *_p_FdOrnsteinUhlenbeckVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdOrnsteinUhlenbeckVanillaEngine *) x));
}
static void *_p_FdBlackScholesVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesVanillaEngine *) x));
}
static void *_p_BatesEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BatesEngine *) x));
}
static void *_p_ContinuousArithmeticAsianLevyEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((ContinuousArithmeticAsianLevyEngine *) x));
}
static void *_p_AnalyticDigitalAmericanKOEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDigitalAmericanKOEngine *) x));
}
static void *_p_AnalyticDoubleBarrierBinaryEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDoubleBarrierBinaryEngine *) 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_KirkEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((KirkEngine *) x));
}
static void *_p_Fd2dBlackScholesVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Fd2dBlackScholesVanillaEngine *) x));
}
static void *_p_AnalyticBSMHullWhiteEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticBSMHullWhiteEngine *) x));
}
static void *_p_MidPointCdsEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MidPointCdsEngine *) x));
}
static void *_p_IntegralCdsEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((IntegralCdsEngine *) x));
}
static void *_p_IsdaCdsEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((IsdaCdsEngine *) x));
}
static void *_p_FDEuropeanEngineT_CrankNicolson_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FDEuropeanEngine< CrankNicolson > *) x));
}
static void *_p_FDBermudanEngineT_CrankNicolson_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FDBermudanEngine< CrankNicolson > *) x));
}
static void *_p_FDAmericanEngineT_CrankNicolson_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FDAmericanEngine< CrankNicolson > *) x));
}
static void *_p_FDShoutEngineT_CrankNicolson_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FDShoutEngine< CrankNicolson > *) x));
}
static void *_p_FDDividendEuropeanEngineT_CrankNicolson_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FDDividendEuropeanEngine< CrankNicolson > *) x));
}
static void *_p_FDDividendAmericanEngineT_CrankNicolson_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FDDividendAmericanEngine< CrankNicolson > *) x));
}
static void *_p_BinomialVanillaEngineT_Tian_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< Tian > *) x));
}
static void *_p_BinomialConvertibleEngineT_Tian_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< Tian > *) 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_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteGeometricAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticASEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCBarrierEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCBarrierEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanHestonEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanHestonEngine< LowDiscrepancy > *) 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_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanGJRGARCHEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanBasketEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanBasketEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEverestEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEverestEngine< LowDiscrepancy > *) x));
}
static void *_p_MCHimalayaEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCHimalayaEngine< LowDiscrepancy > *) x));
}
static void *_p_WulinYongDoubleBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((WulinYongDoubleBarrierEngine *) x));
}
static void *_p_FdHestonDoubleBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonDoubleBarrierEngine *) x));
}
static void *_p_AnalyticDoubleBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDoubleBarrierEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAverageStrikeAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDiscreteGeometricAverageStrikeAsianEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAveragePriceAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDiscreteGeometricAveragePriceAsianEngine *) x));
}
static void *_p_AnalyticContinuousGeometricAveragePriceAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousGeometricAveragePriceAsianEngine *) x));
}
static void *_p_QuantoForwardEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QuantoForwardEuropeanEngine *) x));
}
static void *_p_QuantoEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QuantoEuropeanEngine *) x));
}
static void *_p_ForwardEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((ForwardEuropeanEngine *) x));
}
static void *_p_AnalyticBinaryBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticBinaryBarrierEngine *) x));
}
static void *_p_FdHestonBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonBarrierEngine *) x));
}
static void *_p_FdBlackScholesBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesBarrierEngine *) x));
}
static void *_p_AnalyticCEVEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticCEVEngine *) x));
}
static void *_p_AnalyticBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticBarrierEngine *) x));
}
static void *_p_IntegralEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((IntegralEngine *) x));
}
static void *_p_AnalyticPTDHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticPTDHestonEngine *) x));
}
static void *_p_ExponentialFittingHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((ExponentialFittingHestonEngine *) x));
}
static void *_p_COSHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((COSHestonEngine *) x));
}
static void *_p_AnalyticHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticHestonEngine *) x));
}
static void *_p_AnalyticEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticEuropeanEngine *) x));
}
static void *_p_FdBlackScholesAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesAsianEngine *) x));
}
static void *_p_BaroneAdesiWhaleyApproximationEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BaroneAdesiWhaleyApproximationEngine *) x));
}
static void *_p_BjerksundStenslandApproximationEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BjerksundStenslandApproximationEngine *) x));
}
static void *_p_JuQuadraticApproximationEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((JuQuadraticApproximationEngine *) x));
}
static void *_p_AnalyticDigitalAmericanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDigitalAmericanEngine *) x));
}
static void *_p_AnalyticDividendEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDividendEuropeanEngine *) x));
}
static void *_p_VannaVolgaBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VannaVolgaBarrierEngine *) x));
}
static void *_p_AnalyticGJRGARCHEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticGJRGARCHEngine *) x));
}
static void *_p_KirkSpreadOptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((KirkSpreadOptionEngine *) x));
}
static void *_p_StulzEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((StulzEngine *) x));
}
static void *_p_DiscountingSwapEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((DiscountingSwapEngine *) 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_YoYInflationBachelierCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((YoYInflationBachelierCapFloorEngine *) x));
}
static void *_p_JamshidianSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((JamshidianSwaptionEngine *) x));
}
static void *_p_TreeSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TreeSwaptionEngine *) x));
}
static void *_p_AnalyticCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticCapFloorEngine *) x));
}
static void *_p_TreeCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TreeCapFloorEngine *) x));
}
static void *_p_G2SwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((G2SwaptionEngine *) x));
}
static void *_p_FdG2SwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdG2SwaptionEngine *) x));
}
static void *_p_FdHullWhiteSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHullWhiteSwaptionEngine *) x));
}
static void *_p_DiscountingBondEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((DiscountingBondEngine *) x));
}
static void *_p_TreeCallableFixedRateBondEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TreeCallableFixedRateBondEngine *) 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_BachelierCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BachelierCapFloorEngine *) x));
}
static void *_p_BlackCdsOptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BlackCdsOptionEngine *) x));
}
static void *_p_Gaussian1dSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dSwaptionEngine *) 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_Gaussian1dFloatFloatSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dFloatFloatSwaptionEngine *) x));
}
static void *_p_BlackSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BlackSwaptionEngine *) x));
}
static void *_p_BachelierSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BachelierSwaptionEngine *) 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_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *) 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_BinomialVanillaEngineT_LeisenReimer_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< LeisenReimer > *) x));
}
static void *_p_BinomialConvertibleEngineT_LeisenReimer_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< LeisenReimer > *) 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_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > *) 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_BinomialVanillaEngineT_JarrowRudd_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< JarrowRudd > *) x));
}
static void *_p_BinomialConvertibleEngineT_JarrowRudd_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< JarrowRudd > *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *) x));
}
static void *_p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_BinomialVanillaEngineT_Trigeorgis_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< Trigeorgis > *) x));
}
static void *_p_BinomialConvertibleEngineT_Trigeorgis_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< Trigeorgis > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteGeometricAPEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticASEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticAPEngine< PseudoRandom > *) x));
}
static void *_p_MCBarrierEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCBarrierEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanEngine< PseudoRandom > *) x));
}
static void *_p_MCAmericanEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanHestonEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanGJRGARCHEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanBasketEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCAmericanBasketEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCEverestEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEverestEngine< PseudoRandom > *) x));
}
static void *_p_MCHimalayaEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCHimalayaEngine< PseudoRandom > *) 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_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *) 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_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *) 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_BinomialVanillaEngineT_Joshi4_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< Joshi4 > *) x));
}
static void *_p_BinomialConvertibleEngineT_Joshi4_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< Joshi4 > *) x));
}
static void *_p_LognormalCmsSpreadPricerTo_p_CmsSpreadCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsSpreadCouponPricer *)  ((LognormalCmsSpreadPricer *) x));
}
static void *_p_AnalyticHaganPricerTo_p_CmsCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsCouponPricer *)  ((AnalyticHaganPricer *) x));
}
static void *_p_NumericHaganPricerTo_p_CmsCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsCouponPricer *)  ((NumericHaganPricer *) x));
}
static void *_p_LinearTsrPricerTo_p_CmsCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsCouponPricer *)  ((LinearTsrPricer *) x));
}
static void *_p_BlackIborCouponPricerTo_p_IborCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborCouponPricer *)  ((BlackIborCouponPricer *) x));
}
static void *_p_IborCouponPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *)  ((IborCouponPricer *) 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_AnalyticHaganPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsCouponPricer *) ((AnalyticHaganPricer *) x));
}
static void *_p_NumericHaganPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsCouponPricer *) ((NumericHaganPricer *) x));
}
static void *_p_LinearTsrPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsCouponPricer *) ((LinearTsrPricer *) x));
}
static void *_p_CmsSpreadCouponPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *)  ((CmsSpreadCouponPricer *) x));
}
static void *_p_LognormalCmsSpreadPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsSpreadCouponPricer *) ((LognormalCmsSpreadPricer *) x));
}
static void *_p_EURLiborSWTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLiborSW *) x));
}
static void *_p_EURLibor4MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor4M *) x));
}
static void *_p_EURLibor1YTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor1Y *) x));
}
static void *_p_EURLibor3MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor3M *) x));
}
static void *_p_EURLibor2MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor2M *) 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_EURLibor10MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor10M *) x));
}
static void *_p_EURLibor9MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor9M *) x));
}
static void *_p_EURLibor8MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor8M *) x));
}
static void *_p_EURLibor7MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor7M *) x));
}
static void *_p_EURLibor6MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor6M *) x));
}
static void *_p_EURLibor2WTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor2W *) x));
}
static void *_p_EURLibor5MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor5M *) 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_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_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_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_MultiplicativePriceSeasonalityTo_p_Seasonality(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Seasonality *)  ((MultiplicativePriceSeasonality *) x));
}
static void *_p_KerkhofSeasonalityTo_p_Seasonality(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Seasonality *)  ((KerkhofSeasonality *) x));
}
static void *_p_SimpleQuoteTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((SimpleQuote *) x));
}
static void *_p_DerivedQuoteT_UnaryFunction_tTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((DerivedQuote< UnaryFunction > *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_AndreasenHugeVolatilityInterplTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((AndreasenHugeVolatilityInterpl *) 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_FlatHazardRateTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((FlatHazardRate *) x));
}
static void *_p_PiecewiseFlatHazardRateTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((PiecewiseFlatHazardRate *) x));
}
static void *_p_StochasticProcessArrayTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((StochasticProcessArray *) x));
}
static void *_p_G2To_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((G2 *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EuriborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIfrFix *) x));
}
static void *_p_CHFLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((CHFLibor *) 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_Euribor1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1Y *) x));
}
static void *_p_EURLibor1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_Bibor1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1Y *) x));
}
static void *_p_BlackConstantVolTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackConstantVol *) x));
}
static void *_p_LocalConstantVolTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalConstantVol *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanGJRGARCHEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteGeometricAPEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticASEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticAPEngine< PseudoRandom > *) x));
}
static void *_p_MCBarrierEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCBarrierEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanHestonEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCAmericanEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanBasketEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCAmericanBasketEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCEverestEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEverestEngine< PseudoRandom > *) x));
}
static void *_p_MCHimalayaEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCHimalayaEngine< PseudoRandom > *) x));
}
static void *_p_CoxIngersollRossTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((CoxIngersollRoss *) x));
}
static void *_p_ExtendedCoxIngersollRossTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((ExtendedCoxIngersollRoss *) x));
}
static void *_p_PiecewiseKrugerZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseKrugerZero *) x));
}
static void *_p_CPISwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((CPISwap *) 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_YoYInflationFloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(YoYInflationCapFloor *) ((YoYInflationFloor *) x));
}
static void *_p_BootstrapHelperT_ZeroInflationTermStructure_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((BootstrapHelper< ZeroInflationTermStructure > *) x));
}
static void *_p_BootstrapHelperT_YoYInflationTermStructure_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((BootstrapHelper< YoYInflationTermStructure > *) 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_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_YoYInflationCapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(YoYInflationCapFloor *) ((YoYInflationCap *) x));
}
static void *_p_GBPLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((GBPLibor *) x));
}
static void *_p_BlackVarianceCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceCurve *) x));
}
static void *_p_Euribor2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2M *) x));
}
static void *_p_EURLibor2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2M *) x));
}
static void *_p_Bibor2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor2M *) x));
}
static void *_p_CompositeQuoteT_BinaryFunction_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((CompositeQuote< BinaryFunction > *) x));
}
static void *_p_DerivedQuoteT_UnaryFunction_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((DerivedQuote< UnaryFunction > *) 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_ZeroCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((ZeroCouponBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *)(CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((ConvertibleZeroCouponBond *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((ConvertibleFixedCouponBond *) x));
}
static void *_p_IndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((Index *) x));
}
static void *_p_ShiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Shibor *) x));
}
static void *_p_Bbsw1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw1M *) x));
}
static void *_p_VanillaSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((VanillaSwap *) x));
}
static void *_p_GsrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructureConsistentModel *)(Gaussian1dModel *) ((Gsr *) x));
}
static void *_p_CompositeInstrumentTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((CompositeInstrument *) x));
}
static void *_p_InstrumentTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((Instrument *) x));
}
static void *_p_Euribor2WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2W *) x));
}
static void *_p_EURLibor2WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2W *) x));
}
static void *_p_JpyLiborSwapIsdaFixPmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_AoniaTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Aonia *) 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_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((Bond *) x));
}
static void *_p_PiecewiseCubicZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseCubicZero *) x));
}
static void *_p_BinomialVanillaEngineT_Tian_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< Tian > *) x));
}
static void *_p_SwaptionVolCube1To_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube1 *) x));
}
static void *_p_BinomialConvertibleEngineT_Tian_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< Tian > *) x));
}
static void *_p_SwaptionVolCube2To_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube2 *) x));
}
static void *_p_BinomialVanillaEngineT_LeisenReimer_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< LeisenReimer > *) x));
}
static void *_p_BinomialConvertibleEngineT_LeisenReimer_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< LeisenReimer > *) x));
}
static void *_p_GlobalLinearSimpleZeroCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((GlobalLinearSimpleZeroCurve *) x));
}
static void *_p_IndexedCashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((IndexedCashFlow *) x));
}
static void *_p_SimpleCashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((SimpleCashFlow *) x));
}
static void *_p_CashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((CashFlow *) x));
}
static void *_p_BlackKarasinskiTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((BlackKarasinski *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CmsSpreadCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((CmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_IborCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((IborCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((CappedFlooredCoupon *) x));
}
static void *_p_OvernightIndexedCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((OvernightIndexedCoupon *) x));
}
static void *_p_CouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((Coupon *) x));
}
static void *_p_InflationCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *) ((InflationCoupon *) x));
}
static void *_p_Euribor3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3M *) x));
}
static void *_p_EURLibor3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor3M *) x));
}
static void *_p_Bibor3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor3M *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CmsCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((CmsCoupon *) x));
}
static void *_p_FloatingRateCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *) ((FloatingRateCoupon *) x));
}
static void *_p_FixedRateCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *) ((FixedRateCoupon *) x));
}
static void *_p_UKRPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((UKRPI *) x));
}
static void *_p_CPICouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(InflationCoupon *) ((CPICoupon *) 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_Euribor10MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor10M *) x));
}
static void *_p_EURLibor10MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor10M *) x));
}
static void *_p_Bbsw2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw2M *) x));
}
static void *_p_YYEUHICPrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYEUHICPr *) x));
}
static void *_p_GJRGARCHProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((GJRGARCHProcess *) x));
}
static void *_p_KlugeExtOUProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((KlugeExtOUProcess *) x));
}
static void *_p_ExtOUWithJumpsProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((ExtOUWithJumpsProcess *) x));
}
static void *_p_ExtendedOrnsteinUhlenbeckProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((ExtendedOrnsteinUhlenbeckProcess *) x));
}
static void *_p_OrnsteinUhlenbeckProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((OrnsteinUhlenbeckProcess *) x));
}
static void *_p_GsrProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((GsrProcess *) 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_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_BatesProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(HestonProcess *) ((BatesProcess *) x));
}
static void *_p_HestonProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((HestonProcess *) x));
}
static void *_p_VarianceGammaProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((VarianceGammaProcess *) x));
}
static void *_p_GeometricBrownianMotionProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((GeometricBrownianMotionProcess *) x));
}
static void *_p_Merton76ProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((Merton76Process *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((GarmanKohlagenProcess *) 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_GeneralizedBlackScholesProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((GeneralizedBlackScholesProcess *) x));
}
static void *_p_StochasticProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((StochasticProcess *) x));
}
static void *_p_ShortRateModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((ShortRateModel *) x));
}
static void *_p_OneFactorAffineModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((OneFactorAffineModel *) x));
}
static void *_p_HestonSLVProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((HestonSLVProcess *) x));
}
static void *_p_NZDLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((NZDLibor *) x));
}
static void *_p_AUDLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((AUDLibor *) x));
}
static void *_p_CADLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((CADLibor *) x));
}
static void *_p_USDLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((USDLibor *) x));
}
static void *_p_Euribor3WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3W *) x));
}
static void *_p_BinomialVanillaEngineT_JarrowRudd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< JarrowRudd > *) x));
}
static void *_p_BinomialConvertibleEngineT_JarrowRudd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< JarrowRudd > *) x));
}
static void *_p_OvernightIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((OvernightIndex *) x));
}
static void *_p_ZiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Zibor *) x));
}
static void *_p_CdorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Cdor *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_JPYLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((JPYLibor *) x));
}
static void *_p_EUHICPXTTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((EUHICPXT *) x));
}
static void *_p_YYEUHICPXTTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYEUHICPXT *) x));
}
static void *_p_CallableBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((CallableBond *) 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_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< Trigeorgis,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_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_NonstandardSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((NonstandardSwap *) x));
}
static void *_p_PiecewiseLogLinearDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLogLinearDiscount *) x));
}
static void *_p_PiecewiseLogCubicDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLogCubicDiscount *) x));
}
static void *_p_PiecewiseSplineCubicDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseSplineCubicDiscount *) x));
}
static void *_p_PiecewiseKrugerLogDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseKrugerLogDiscount *) x));
}
static void *_p_SimpleQuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((SimpleQuote *) x));
}
static void *_p_CreditDefaultSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((CreditDefaultSwap *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((SwaptionVolatilityDiscrete *) x));
}
static void *_p_Euribor4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor4M *) x));
}
static void *_p_EURLibor4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor4M *) 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_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_Euribor11MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor11M *) x));
}
static void *_p_EURLibor11MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor11M *) x));
}
static void *_p_Bbsw3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw3M *) x));
}
static void *_p_CalibratedModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((CalibratedModel *) x));
}
static void *_p_FloatFloatSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((FloatFloatSwap *) x));
}
static void *_p_Gaussian1dModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructureConsistentModel *) ((Gaussian1dModel *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_BarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_MultiAssetOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *) ((MultiAssetOption *) x));
}
static void *_p_EuropeanOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_OneAssetOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *) ((OneAssetOption *) x));
}
static void *_p_OptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((Option *) x));
}
static void *_p_EURLiborSWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EuriborSWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((EuriborSW *) x));
}
static void *_p_BiborSWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((BiborSW *) x));
}
static void *_p_SpreadOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_BasketOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_EverestOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(MultiAssetOption *) ((EverestOption *) x));
}
static void *_p_VanillaSwingOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((VanillaSwingOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((DividendVanillaOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *)(ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((QuantoVanillaOption *) x));
}
static void *_p_ForwardVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((ForwardVanillaOption *) x));
}
static void *_p_VanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(OneAssetOption *) ((VanillaOption *) x));
}
static void *_p_HimalayaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *)(MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_CdsOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *) ((CdsOption *) x));
}
static void *_p_StochasticProcess1DTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((StochasticProcess1D *) x));
}
static void *_p_AmortizingPaymentTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((AmortizingPayment *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_ZACPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((ZACPI *) x));
}
static void *_p_Bkbm1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm1M *) x));
}
static void *_p_SofrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sofr *) x));
}
static void *_p_AnalyticGJRGARCHEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticGJRGARCHEngine *) x));
}
static void *_p_VannaVolgaBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VannaVolgaBarrierEngine *) x));
}
static void *_p_WulinYongDoubleBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((WulinYongDoubleBarrierEngine *) x));
}
static void *_p_FdHestonDoubleBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonDoubleBarrierEngine *) x));
}
static void *_p_AnalyticDoubleBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDoubleBarrierEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAverageStrikeAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDiscreteGeometricAverageStrikeAsianEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAveragePriceAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDiscreteGeometricAveragePriceAsianEngine *) x));
}
static void *_p_AnalyticContinuousGeometricAveragePriceAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousGeometricAveragePriceAsianEngine *) x));
}
static void *_p_QuantoForwardEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QuantoForwardEuropeanEngine *) x));
}
static void *_p_QuantoEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QuantoEuropeanEngine *) x));
}
static void *_p_ForwardEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((ForwardEuropeanEngine *) x));
}
static void *_p_AnalyticBinaryBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticBinaryBarrierEngine *) x));
}
static void *_p_FdHestonBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonBarrierEngine *) x));
}
static void *_p_FdBlackScholesBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesBarrierEngine *) x));
}
static void *_p_AnalyticCEVEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticCEVEngine *) x));
}
static void *_p_AnalyticBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticBarrierEngine *) x));
}
static void *_p_AnalyticDividendEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDividendEuropeanEngine *) x));
}
static void *_p_AnalyticDigitalAmericanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDigitalAmericanEngine *) x));
}
static void *_p_JuQuadraticApproximationEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((JuQuadraticApproximationEngine *) x));
}
static void *_p_BjerksundStenslandApproximationEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BjerksundStenslandApproximationEngine *) x));
}
static void *_p_BaroneAdesiWhaleyApproximationEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BaroneAdesiWhaleyApproximationEngine *) x));
}
static void *_p_FdBlackScholesAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesAsianEngine *) x));
}
static void *_p_IntegralEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((IntegralEngine *) x));
}
static void *_p_AnalyticPTDHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticPTDHestonEngine *) x));
}
static void *_p_ExponentialFittingHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((ExponentialFittingHestonEngine *) x));
}
static void *_p_COSHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((COSHestonEngine *) x));
}
static void *_p_AnalyticHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticHestonEngine *) x));
}
static void *_p_AnalyticEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticEuropeanEngine *) x));
}
static void *_p_KirkSpreadOptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((KirkSpreadOptionEngine *) x));
}
static void *_p_StulzEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((StulzEngine *) x));
}
static void *_p_DiscountingSwapEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((DiscountingSwapEngine *) x));
}
static void *_p_YoYInflationBlackCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((YoYInflationBlackCapFloorEngine *) x));
}
static void *_p_YoYInflationUnitDisplacedBlackCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((YoYInflationUnitDisplacedBlackCapFloorEngine *) x));
}
static void *_p_YoYInflationBachelierCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((YoYInflationBachelierCapFloorEngine *) x));
}
static void *_p_JamshidianSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((JamshidianSwaptionEngine *) x));
}
static void *_p_TreeSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TreeSwaptionEngine *) x));
}
static void *_p_AnalyticCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticCapFloorEngine *) x));
}
static void *_p_TreeCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TreeCapFloorEngine *) x));
}
static void *_p_G2SwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((G2SwaptionEngine *) x));
}
static void *_p_FdG2SwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdG2SwaptionEngine *) x));
}
static void *_p_FdHullWhiteSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHullWhiteSwaptionEngine *) x));
}
static void *_p_DiscountingBondEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((DiscountingBondEngine *) x));
}
static void *_p_TreeCallableFixedRateBondEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TreeCallableFixedRateBondEngine *) 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_BachelierCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BachelierCapFloorEngine *) x));
}
static void *_p_BlackCdsOptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BlackCdsOptionEngine *) x));
}
static void *_p_Gaussian1dSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dSwaptionEngine *) x));
}
static void *_p_Gaussian1dJamshidianSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dJamshidianSwaptionEngine *) x));
}
static void *_p_Gaussian1dNonstandardSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dNonstandardSwaptionEngine *) x));
}
static void *_p_Gaussian1dFloatFloatSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dFloatFloatSwaptionEngine *) x));
}
static void *_p_BlackSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BlackSwaptionEngine *) x));
}
static void *_p_BachelierSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BachelierSwaptionEngine *) x));
}
static void *_p_FdSimpleExtOUJumpSwingEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdSimpleExtOUJumpSwingEngine *) x));
}
static void *_p_FdSimpleBSSwingEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdSimpleBSSwingEngine *) x));
}
static void *_p_AnalyticDoubleBarrierBinaryEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDoubleBarrierBinaryEngine *) x));
}
static void *_p_FFTVarianceGammaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FFTVarianceGammaEngine *) x));
}
static void *_p_VarianceGammaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VarianceGammaEngine *) x));
}
static void *_p_FdHestonRebateEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonRebateEngine *) x));
}
static void *_p_FdBlackScholesRebateEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesRebateEngine *) x));
}
static void *_p_FdSabrVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdSabrVanillaEngine *) x));
}
static void *_p_FdCEVVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdCEVVanillaEngine *) x));
}
static void *_p_FdHestonVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonVanillaEngine *) x));
}
static void *_p_FdBatesVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBatesVanillaEngine *) x));
}
static void *_p_FdOrnsteinUhlenbeckVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdOrnsteinUhlenbeckVanillaEngine *) x));
}
static void *_p_FdBlackScholesVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesVanillaEngine *) x));
}
static void *_p_AnalyticDigitalAmericanKOEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDigitalAmericanKOEngine *) x));
}
static void *_p_ContinuousArithmeticAsianLevyEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((ContinuousArithmeticAsianLevyEngine *) x));
}
static void *_p_BatesEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BatesEngine *) x));
}
static void *_p_PricingEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((PricingEngine *) x));
}
static void *_p_KirkEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((KirkEngine *) x));
}
static void *_p_Fd2dBlackScholesVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Fd2dBlackScholesVanillaEngine *) x));
}
static void *_p_AnalyticBSMHullWhiteEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticBSMHullWhiteEngine *) x));
}
static void *_p_MidPointCdsEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MidPointCdsEngine *) x));
}
static void *_p_IntegralCdsEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((IntegralCdsEngine *) x));
}
static void *_p_IsdaCdsEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((IsdaCdsEngine *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > *) x));
}
static void *_p_PiecewiseTimeDependentHestonModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((PiecewiseTimeDependentHestonModel *) x));
}
static void *_p_HestonModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((HestonModel *) x));
}
static void *_p_BootstrapHelperT_YoYOptionletVolatilitySurface_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((BootstrapHelper< YoYOptionletVolatilitySurface > *) x));
}
static void *_p_FloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(CapFloor *) ((Floor *) x));
}
static void *_p_Euribor5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor5M *) x));
}
static void *_p_EURLibor5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor5M *) 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_SoniaTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sonia *) x));
}
static void *_p_Bbsw4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw4M *) x));
}
static void *_p_ForwardSpreadedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((ForwardSpreadedTermStructure *) x));
}
static void *_p_ZeroSpreadedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((ZeroSpreadedTermStructure *) x));
}
static void *_p_ImpliedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((ImpliedTermStructure *) x));
}
static void *_p_YieldTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((YieldTermStructure *) x));
}
static void *_p_TermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((TermStructure *) x));
}
static void *_p_VolatilityTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((VolatilityTermStructure *) x));
}
static void *_p_BlackVolTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((BlackVolTermStructure *) x));
}
static void *_p_LocalVolTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((LocalVolTermStructure *) x));
}
static void *_p_OptionletVolatilityStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((OptionletVolatilityStructure *) x));
}
static void *_p_SwaptionVolatilityStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((SwaptionVolatilityStructure *) x));
}
static void *_p_InflationTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((InflationTermStructure *) x));
}
static void *_p_YoYInflationTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *) ((YoYInflationTermStructure *) x));
}
static void *_p_ZeroInflationTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *) ((ZeroInflationTermStructure *) x));
}
static void *_p_DefaultProbabilityTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((DefaultProbabilityTermStructure *) x));
}
static void *_p_CapFloorTermVolatilityStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((CapFloorTermVolatilityStructure *) x));
}
static void *_p_NzocrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Nzocr *) x));
}
static void *_p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_PriborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Pribor *) x));
}
static void *_p_IborIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *) ((IborIndex *) x));
}
static void *_p_YYUSCPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUSCPI *) x));
}
static void *_p_JibarTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Jibar *) x));
}
static void *_p_PiecewiseLinearZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLinearZero *) x));
}
static void *_p_YYUKRPIrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUKRPIr *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolCurve *) x));
}
static void *_p_Bkbm2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm2M *) x));
}
static void *_p_BbswTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Bbsw *) x));
}
static void *_p_InterpolatedSmileSectionT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((InterpolatedSmileSection< Linear > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteGeometricAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticASEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCBarrierEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCBarrierEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanHestonEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanGJRGARCHEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanBasketEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanBasketEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEverestEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEverestEngine< LowDiscrepancy > *) x));
}
static void *_p_MCHimalayaEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCHimalayaEngine< LowDiscrepancy > *) 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_PiecewiseYoYInflationCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(YoYInflationTermStructure *) ((PiecewiseYoYInflationCurve< Linear > *) 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_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_InterpolatedDefaultDensityCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((InterpolatedDefaultDensityCurve< Linear > *) 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_InterpolatedDiscountCurveT_LogLinear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< LogLinear > *) 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_PiecewiseConvexMonotoneZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseConvexMonotoneZero *) x));
}
static void *_p_OvernightIndexedSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((OvernightIndexedSwap *) x));
}
static void *_p_Euribor6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor6M *) x));
}
static void *_p_EURLibor6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor6M *) x));
}
static void *_p_Bibor6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor6M *) 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_YYFRHICPrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYFRHICPr *) x));
}
static void *_p_Bbsw5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw5M *) x));
}
static void *_p_FixedRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((FixedRateBond *) x));
}
static void *_p_AmortizingFixedRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((AmortizingFixedRateBond *) x));
}
static void *_p_AmortizingFloatingRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((AmortizingFloatingRateBond *) x));
}
static void *_p_FloatingRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((FloatingRateBond *) x));
}
static void *_p_CmsRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((CmsRateBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *)(CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((ConvertibleFloatingRateBond *) x));
}
static void *_p_BinomialVanillaEngineT_CoxRossRubinstein_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< CoxRossRubinstein > *) x));
}
static void *_p_YoYInflationCollarTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(YoYInflationCapFloor *) ((YoYInflationCollar *) x));
}
static void *_p_CollarTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(CapFloor *) ((Collar *) x));
}
static void *_p_BinomialConvertibleEngineT_CoxRossRubinstein_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< CoxRossRubinstein > *) x));
}
static void *_p_RedemptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((Redemption *) 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_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_SmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((SmileSection *) x));
}
static void *_p_SabrSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((SabrSmileSection *) x));
}
static void *_p_FlatSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((FlatSmileSection *) x));
}
static void *_p_KahaleSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((KahaleSmileSection *) x));
}
static void *_p_HullWhiteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *)(OneFactorAffineModel *)(Vasicek *) ((HullWhite *) x));
}
static void *_p_WiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Wibor *) x));
}
static void *_p_Bkbm3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm3M *) x));
}
static void *_p_BiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Bibor *) x));
}
static void *_p_DKKLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((DKKLibor *) x));
}
static void *_p_SEKLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((SEKLibor *) x));
}
static void *_p_ZeroCouponInflationSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((ZeroCouponInflationSwap *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((YearOnYearInflationSwap *) 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_Euribor7MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor7M *) x));
}
static void *_p_EURLibor7MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor7M *) x));
}
static void *_p_CPIBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Bond *) ((CPIBond *) x));
}
static void *_p_LiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Libor *) x));
}
static void *_p_Bbsw6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw6M *) x));
}
static void *_p_SwapIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *) ((SwapIndex *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((OvernightIndexedSwapIndex *) x));
}
static void *_p_DeltaVolQuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((DeltaVolQuote *) x));
}
static void *_p_SwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((Swap *) x));
}
static void *_p_FlatForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((FlatForward *) x));
}
static void *_p_BkbmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Bkbm *) x));
}
static void *_p_PiecewiseFlatForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseFlatForward *) x));
}
static void *_p_PiecewiseLinearForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLinearForward *) x));
}
static void *_p_ForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((Forward *) x));
}
static void *_p_FixedRateBondForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Forward *) ((FixedRateBondForward *) x));
}
static void *_p_SwaptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Option *) ((Swaption *) x));
}
static void *_p_NonstandardSwaptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((NonstandardSwaption *) x));
}
static void *_p_FloatFloatSwaptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((FloatFloatSwaption *) x));
}
static void *_p_InterestRateIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *) ((InterestRateIndex *) x));
}
static void *_p_Bkbm4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm4M *) x));
}
static void *_p_MarkovFunctionalTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructureConsistentModel *)(Gaussian1dModel *) ((MarkovFunctional *) x));
}
static void *_p_EUHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((EUHICP *) x));
}
static void *_p_YYEUHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYEUHICP *) 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_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_HestonBlackVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((HestonBlackVolSurface *) x));
}
static void *_p_YoYOptionletVolatilitySurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((YoYOptionletVolatilitySurface *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceSurface *) x));
}
static void *_p_LocalVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalVolSurface *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *)(LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_YoYCapFloorTermPriceSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *) ((YoYCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationCapFloorTermPriceSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(YoYCapFloorTermPriceSurface *) ((YoYInflationCapFloorTermPriceSurface *) 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_CapFloorTermVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolSurface *) 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_SplineCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< SplineCubic > *) 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_MonotonicCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< MonotonicCubic > *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixB *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_Euribor8MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor8M *) x));
}
static void *_p_EURLibor8MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor8M *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_AUCPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((AUCPI *) x));
}
static void *_p_FittedBondDiscountCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((FittedBondDiscountCurve *) x));
}
static void *_p_YYUSCPIrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUSCPIr *) 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_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((InterpolatedHazardRateCurve< BackwardFlat > *) 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_MosprimeTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Mosprime *) x));
}
static void *_p_SwapSpreadIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *) ((SwapSpreadIndex *) x));
}
static void *_p_QuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((Quote *) x));
}
static void *_p_Bkbm5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm5M *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrFullFd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrFullFd > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrFullFd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrFullFd > *) x));
}
static void *_p_EoniaTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Eonia *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 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_ZabrSmileSectionT_ZabrShortMaturityNormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityLognormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_ZeroCouponInflationSwapHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (BootstrapHelper< ZeroInflationTermStructure > *) ((ZeroCouponInflationSwapHelper *) x));
}
static void *_p_YearOnYearInflationSwapHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (BootstrapHelper< YoYInflationTermStructure > *) ((YearOnYearInflationSwapHelper *) x));
}
static void *_p_YoYOptionletHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (BootstrapHelper< YoYOptionletVolatilitySurface > *) ((YoYOptionletHelper *) x));
}
static void *_p_BondHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((BondHelper *) x));
}
static void *_p_FixedRateBondHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *)(BondHelper *) ((FixedRateBondHelper *) x));
}
static void *_p_USCPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((USCPI *) x));
}
static void *_p_RateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((RateHelper *) x));
}
static void *_p_DepositRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((DepositRateHelper *) x));
}
static void *_p_FraRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((FraRateHelper *) x));
}
static void *_p_FuturesRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((FuturesRateHelper *) x));
}
static void *_p_SwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((SwapRateHelper *) x));
}
static void *_p_OISRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((OISRateHelper *) x));
}
static void *_p_DatedOISRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((DatedOISRateHelper *) x));
}
static void *_p_FxSwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((FxSwapRateHelper *) x));
}
static void *_p_OvernightIndexFutureRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((OvernightIndexFutureRateHelper *) x));
}
static void *_p_SofrFutureRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *)(OvernightIndexFutureRateHelper *) ((SofrFutureRateHelper *) x));
}
static void *_p_DefaultProbabilityHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((DefaultProbabilityHelper *) x));
}
static void *_p_SpreadCdsHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (DefaultProbabilityHelper *) ((SpreadCdsHelper *) x));
}
static void *_p_UpfrontCdsHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (DefaultProbabilityHelper *) ((UpfrontCdsHelper *) x));
}
static void *_p_Euribor9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor9M *) x));
}
static void *_p_EURLibor9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor9M *) x));
}
static void *_p_Bibor9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor9M *) 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_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *) x));
}
static void *_p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *) x));
}
static void *_p_InflationIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *) ((InflationIndex *) x));
}
static void *_p_ZeroInflationIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *) ((ZeroInflationIndex *) x));
}
static void *_p_YoYInflationIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *) ((YoYInflationIndex *) 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_Euribor365_2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_TermStructureConsistentModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((TermStructureConsistentModel *) 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_TiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Tibor *) x));
}
static void *_p_FedFundsTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((FedFunds *) x));
}
static void *_p_Bkbm6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm6M *) x));
}
static void *_p_VasicekTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *)(OneFactorAffineModel *) ((Vasicek *) 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_THBFIXTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((THBFIX *) x));
}
static void *_p_FRHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((FRHICP *) x));
}
static void *_p_YYFRHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYFRHICP *) x));
}
static void *_p_YYUKRPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUKRPI *) x));
}
static void *_p_ZabrSmileSectionT_ZabrLocalVolatility_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_BinomialVanillaEngineT_Joshi4_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< Joshi4 > *) x));
}
static void *_p_BinomialConvertibleEngineT_Joshi4_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< Joshi4 > *) x));
}
static void *_p_FDDividendAmericanEngineT_CrankNicolson_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FDDividendAmericanEngine< CrankNicolson > *) x));
}
static void *_p_FDDividendEuropeanEngineT_CrankNicolson_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FDDividendEuropeanEngine< CrankNicolson > *) x));
}
static void *_p_FDShoutEngineT_CrankNicolson_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FDShoutEngine< CrankNicolson > *) x));
}
static void *_p_FDAmericanEngineT_CrankNicolson_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FDAmericanEngine< CrankNicolson > *) x));
}
static void *_p_FDEuropeanEngineT_CrankNicolson_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FDEuropeanEngine< CrankNicolson > *) x));
}
static void *_p_FDBermudanEngineT_CrankNicolson_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FDBermudanEngine< CrankNicolson > *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *) x));
}
static void *_p_YoYInflationCapFloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((YoYInflationCapFloor *) x));
}
static void *_p_CapFloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((CapFloor *) 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_DividendTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((Dividend *) x));
}
static void *_p_FixedDividendTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Dividend *) ((FixedDividend *) x));
}
static void *_p_FractionalDividendTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Dividend *) ((FractionalDividend *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(OptionletVolatilityStructure *) ((StrippedOptionletAdapter *) x));
}
static void *_p_ForwardRateAgreementTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Forward *) ((ForwardRateAgreement *) x));
}
static void *_p_Euribor365To_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Euribor365 *) x));
}
static void *_p_BatesModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(HestonModel *) ((BatesModel *) x));
}
static void *_p_CADLiborONTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_GBPLiborONTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_USDLiborONTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((USDLiborON *) 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_DailyTenorLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((DailyTenorLibor *) x));
}
static void *_p_TRLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((TRLibor *) x));
}
static void *_p_EURLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((EURLibor *) x));
}
static void *_p_StockTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *) ((Stock *) 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_AssetSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(Swap *) ((AssetSwap *) x));
}
static void *_p_GJRGARCHModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((GJRGARCHModel *) 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_EuriborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Euribor *) x));
}
static void *_p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_BinomialVanillaEngineT_Trigeorgis_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< Trigeorgis > *) x));
}
static void *_p_BinomialConvertibleEngineT_Trigeorgis_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< Trigeorgis > *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) 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_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_YYZACPIrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYZACPIr *) 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_RoborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Robor *) x));
}
static void *_p_CapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Instrument *)(CapFloor *) ((Cap *) x));
}
static void *_p_YYZACPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYZACPI *) x));
}
static void *_p_Euribor1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1M *) x));
}
static void *_p_EURLibor1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1M *) x));
}
static void *_p_Bibor1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1M *) 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_ZeroInflationTermStructure_tTo_p_HandleT_ZeroInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< ZeroInflationTermStructure > *)  ((RelinkableHandle< ZeroInflationTermStructure > *) 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 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_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_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_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_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_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_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_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_RelinkableHandleT_OptionletVolatilityStructure_tTo_p_HandleT_OptionletVolatilityStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< OptionletVolatilityStructure > *)  ((RelinkableHandle< OptionletVolatilityStructure > *) 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_SwaptionVolatilityStructure_tTo_p_HandleT_SwaptionVolatilityStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< SwaptionVolatilityStructure > *)  ((RelinkableHandle< SwaptionVolatilityStructure > *) 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_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_SwaptionVolCube2_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< SwaptionVolCube2 > *)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_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_SwaptionVolCube1_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< SwaptionVolCube1 > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_SwaptionVolCube1_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< SwaptionVolCube1 > *)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_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_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_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_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_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_SwaptionVolCube2_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< SwaptionVolCube2 > *)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_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_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_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_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_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_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_RelinkableHandleT_YieldTermStructure_tTo_p_HandleT_YieldTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< YieldTermStructure > *)  ((RelinkableHandle< YieldTermStructure > *) x));
}
static void *_p_ZeroCouponInflationSwapHelperTo_p_BootstrapHelperT_ZeroInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BootstrapHelper< ZeroInflationTermStructure > *)  ((ZeroCouponInflationSwapHelper *) x));
}
static void *_p_YearOnYearInflationSwapHelperTo_p_BootstrapHelperT_YoYInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BootstrapHelper< YoYInflationTermStructure > *)  ((YearOnYearInflationSwapHelper *) 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_CapFloorTermVolatilityStructure_tTo_p_HandleT_CapFloorTermVolatilityStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< CapFloorTermVolatilityStructure > *)  ((RelinkableHandle< CapFloorTermVolatilityStructure > *) x));
}
static void *_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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< InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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< InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_SwaptionVolCube2_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< SwaptionVolCube2 > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_SwaptionVolCube1_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< SwaptionVolCube1 > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_InterpolatedPiecewiseZeroSpreadedTermStructureT_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< InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_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< InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > > *)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_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_WiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Wibor *) x));
}
static void *_p_Bbsw1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Euribor365To_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Euribor365 *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_EURLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((EURLibor *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EuriborSwapIsdaFixB *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_Euribor365_1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_1Y *) x));
}
static void *_p_Bbsw6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw6M *) x));
}
static void *_p_EURLibor3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor3M *) x));
}
static void *_p_Euribor3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor3M *) x));
}
static void *_p_Bibor3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor3M *) x));
}
static void *_p_Bkbm1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm1M *) x));
}
static void *_p_EURLibor8MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor8M *) x));
}
static void *_p_Euribor8MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor8M *) x));
}
static void *_p_GBPLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((GBPLibor *) x));
}
static void *_p_Euribor365_4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_4M *) x));
}
static void *_p_Bkbm6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm6M *) x));
}
static void *_p_AoniaTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Aonia *) x));
}
static void *_p_Euribor365_9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_9M *) x));
}
static void *_p_EURLiborSWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EuriborSWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((EuriborSW *) x));
}
static void *_p_RoborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Robor *) x));
}
static void *_p_BiborSWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((BiborSW *) x));
}
static void *_p_SoniaTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Sonia *) x));
}
static void *_p_BbswTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Bbsw *) x));
}
static void *_p_FedFundsTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((FedFunds *) x));
}
static void *_p_Euribor3WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor3W *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_CdorTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Cdor *) x));
}
static void *_p_ShiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Shibor *) x));
}
static void *_p_Bbsw4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw4M *) x));
}
static void *_p_EURLibor1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor1M *) x));
}
static void *_p_Euribor1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor1M *) x));
}
static void *_p_Bibor1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor1M *) x));
}
static void *_p_EURLibor6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor6M *) x));
}
static void *_p_Euribor6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor6M *) x));
}
static void *_p_Bibor6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor6M *) x));
}
static void *_p_Euribor365_2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_Bkbm4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm4M *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EuriborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EurLiborSwapIfrFix *) x));
}
static void *_p_Euribor365_7MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_7M *) x));
}
static void *_p_NZDLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((NZDLibor *) x));
}
static void *_p_ZiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Zibor *) x));
}
static void *_p_Euribor365_10MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_10M *) x));
}
static void *_p_EURLibor11MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor11M *) x));
}
static void *_p_Euribor11MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor11M *) x));
}
static void *_p_DailyTenorLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((DailyTenorLibor *) x));
}
static void *_p_TRLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((TRLibor *) x));
}
static void *_p_EURLibor1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_Euribor1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor1Y *) x));
}
static void *_p_Bibor1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor1Y *) x));
}
static void *_p_CADLiborONTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_GBPLiborONTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_PriborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Pribor *) x));
}
static void *_p_USDLiborONTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_Bbsw2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw2M *) x));
}
static void *_p_Euribor365_2WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_2W *) x));
}
static void *_p_EURLibor4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor4M *) x));
}
static void *_p_Euribor4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor4M *) x));
}
static void *_p_EURLibor9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor9M *) x));
}
static void *_p_Euribor9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor9M *) x));
}
static void *_p_Bkbm2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bibor9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor9M *) x));
}
static void *_p_Euribor365_5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_5M *) x));
}
static void *_p_DKKLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((DKKLibor *) x));
}
static void *_p_SEKLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((SEKLibor *) x));
}
static void *_p_EoniaTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Eonia *) x));
}
static void *_p_SwapIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *)  ((SwapIndex *) x));
}
static void *_p_BiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Bibor *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((OvernightIndexedSwapIndex *) x));
}
static void *_p_CHFLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((CHFLibor *) x));
}
static void *_p_EuriborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Euribor *) x));
}
static void *_p_Bbsw5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw5M *) x));
}
static void *_p_EURLibor2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor2M *) x));
}
static void *_p_Euribor2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor2M *) x));
}
static void *_p_Bibor2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor2M *) x));
}
static void *_p_TiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Tibor *) x));
}
static void *_p_EURLibor7MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor7M *) x));
}
static void *_p_Euribor7MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor7M *) x));
}
static void *_p_SofrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Sofr *) x));
}
static void *_p_Euribor365_3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_3M *) x));
}
static void *_p_Bkbm5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm5M *) x));
}
static void *_p_Euribor365_8MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_8M *) x));
}
static void *_p_LiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Libor *) x));
}
static void *_p_Euribor365_11MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_11M *) x));
}
static void *_p_EURLibor2WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor2W *) x));
}
static void *_p_Euribor2WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor2W *) x));
}
static void *_p_Euribor365_SWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_SW *) x));
}
static void *_p_BkbmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Bkbm *) x));
}
static void *_p_Bbsw3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw3M *) x));
}
static void *_p_Euribor365_3WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_3W *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_OvernightIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((OvernightIndex *) x));
}
static void *_p_JibarTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Jibar *) x));
}
static void *_p_SwapSpreadIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *)  ((SwapSpreadIndex *) x));
}
static void *_p_EURLibor5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor5M *) x));
}
static void *_p_Euribor5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor5M *) x));
}
static void *_p_Euribor365_1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_1M *) x));
}
static void *_p_Bkbm3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm3M *) x));
}
static void *_p_JPYLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((JPYLibor *) x));
}
static void *_p_IborIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *)  ((IborIndex *) x));
}
static void *_p_Euribor365_6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_6M *) x));
}
static void *_p_JpyLiborSwapIsdaFixPmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_MosprimeTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Mosprime *) x));
}
static void *_p_THBFIXTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((THBFIX *) x));
}
static void *_p_EURLibor10MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor10M *) x));
}
static void *_p_Euribor10MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor10M *) x));
}
static void *_p_NzocrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Nzocr *) x));
}
static void *_p_CADLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((CADLibor *) x));
}
static void *_p_AUDLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((AUDLibor *) x));
}
static void *_p_USDLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((USDLibor *) 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_ForwardRateAgreement_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< ForwardRateAgreement > *)x);
}
static void *_p_BoundaryConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((BoundaryConstraint *) x));
}
static void *_p_NoConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((NoConstraint *) x));
}
static void *_p_PositiveConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((PositiveConstraint *) x));
}
static void *_p_CompositeConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((CompositeConstraint *) x));
}
static void *_p_NonhomogeneousBoundaryConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((NonhomogeneousBoundaryConstraint *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_WulinYongDoubleBarrierEngine_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< WulinYongDoubleBarrierEngine > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_FDEuropeanEngineT_CrankNicolson_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< FDEuropeanEngine< CrankNicolson > > *)x);
}
static void *_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_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< FDBermudanEngine< CrankNicolson > > *)x);
}
static void *_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_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< FDAmericanEngine< CrankNicolson > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_FDShoutEngineT_CrankNicolson_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< FDShoutEngine< CrankNicolson > > *)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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_WulinYongDoubleBarrierEngine_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< WulinYongDoubleBarrierEngine > > *)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_FDDividendEuropeanEngineT_CrankNicolson_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< FDDividendEuropeanEngine< CrankNicolson > > *)x);
}
static void *_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_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< FDDividendAmericanEngine< CrankNicolson > > *)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_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_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_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_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_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_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_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_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_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_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_KahaleSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((KahaleSmileSection *) x));
}
static void *_p_FlatSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((FlatSmileSection *) x));
}
static void *_p_SabrSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((SabrSmileSection *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityNormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityLognormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_NoArbSabrSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((NoArbSabrSmileSection *) x));
}
static void *_p_NoArbSabrInterpolatedSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((NoArbSabrInterpolatedSmileSection *) x));
}
static void *_p_InterpolatedSmileSectionT_SplineCubic_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< SplineCubic > *) x));
}
static void *_p_InterpolatedSmileSectionT_MonotonicCubic_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< MonotonicCubic > *) x));
}
static void *_p_InterpolatedSmileSectionT_Cubic_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< Cubic > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrFullFd_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrFullFd > *) 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_InterpolatedSmileSectionT_Linear_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< Linear > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrLocalVolatility_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_BondHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((BondHelper *) x));
}
static void *_p_FixedRateBondHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *) (BondHelper *) ((FixedRateBondHelper *) x));
}
static void *_p_DepositRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((DepositRateHelper *) 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_SwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((SwapRateHelper *) x));
}
static void *_p_OISRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((OISRateHelper *) x));
}
static void *_p_DatedOISRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((DatedOISRateHelper *) x));
}
static void *_p_FxSwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((FxSwapRateHelper *) 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_SofrFutureRateHelperTo_p_OvernightIndexFutureRateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndexFutureRateHelper *)  ((SofrFutureRateHelper *) 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_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_PiecewiseZeroInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (ZeroInflationTermStructure *) ((PiecewiseZeroInflationCurve< 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_InterpolatedZeroInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (ZeroInflationTermStructure *) ((InterpolatedZeroInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedYoYInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (YoYInflationTermStructure *) ((InterpolatedYoYInflationCurve< 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_SwaptionVolCube1To_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube1 *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolCube2To_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube2 *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *)  ((ConstantSwaptionVolatility *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *)  ((SwaptionVolatilityDiscrete *) 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_FittedBondDiscountCurveTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((FittedBondDiscountCurve *) x));
}
static void *_p_PiecewiseLinearForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLinearForward *) x));
}
static void *_p_PiecewiseFlatForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseFlatForward *) x));
}
static void *_p_FlatForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((FlatForward *) x));
}
static void *_p_PiecewiseConvexMonotoneZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseConvexMonotoneZero *) x));
}
static void *_p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *) x));
}
static void *_p_PiecewiseKrugerZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseKrugerZero *) x));
}
static void *_p_GlobalLinearSimpleZeroCurveTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((GlobalLinearSimpleZeroCurve *) 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_InterpolatedZeroCurveT_Cubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< Cubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_SplineCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< SplineCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< DefaultLogCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< MonotonicCubic > *) x));
}
static void *_p_PiecewiseCubicZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseCubicZero *) x));
}
static void *_p_PiecewiseSplineCubicDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseSplineCubicDiscount *) 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_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *) x));
}
static void *_p_PiecewiseKrugerLogDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseKrugerLogDiscount *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogLinear_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< LogLinear > *) 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_InterpolatedForwardCurveT_BackwardFlat_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedForwardCurve< BackwardFlat > *) x));
}
static void *_p_ForwardSpreadedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((ForwardSpreadedTermStructure *) x));
}
static void *_p_ZeroSpreadedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((ZeroSpreadedTermStructure *) x));
}
static void *_p_ImpliedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((ImpliedTermStructure *) x));
}
static void *_p_PiecewiseLinearZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLinearZero *) x));
}
static void *_p_BlackVarianceCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceCurve *) x));
}
static void *_p_PiecewiseLinearZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLinearZero *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) 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_InterpolatedZeroCurveT_Cubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< Cubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_SplineCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< SplineCubic > *) 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_MonotonicCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< MonotonicCubic > *) x));
}
static void *_p_LocalConstantVolTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalConstantVol *) x));
}
static void *_p_BlackConstantVolTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackConstantVol *) 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_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_PiecewiseYoYInflationCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *)(YoYInflationTermStructure *) ((PiecewiseYoYInflationCurve< Linear > *) 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_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_InterpolatedDefaultDensityCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((InterpolatedDefaultDensityCurve< Linear > *) x));
}
static void *_p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((InterpolatedSurvivalProbabilityCurve< Linear > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogLinear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< LogLinear > *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(OptionletVolatilityStructure *) ((StrippedOptionletAdapter *) 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_ConstantYoYOptionletVolatilityTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((ConstantSwaptionVolatility *) x));
}
static void *_p_ConstantOptionletVolatilityTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(OptionletVolatilityStructure *) ((ConstantOptionletVolatility *) x));
}
static void *_p_PiecewiseKrugerZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseKrugerZero *) x));
}
static void *_p_PiecewiseCubicZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseCubicZero *) x));
}
static void *_p_HestonBlackVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((HestonBlackVolSurface *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *)(LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_LocalVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalVolSurface *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceSurface *) x));
}
static void *_p_YoYOptionletVolatilitySurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((YoYOptionletVolatilitySurface *) 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_CapFloorTermVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolSurface *) x));
}
static void *_p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((InterpolatedHazardRateCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedForwardCurve< BackwardFlat > *) x));
}
static void *_p_FittedBondDiscountCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((FittedBondDiscountCurve *) x));
}
static void *_p_ZeroInflationTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *) ((ZeroInflationTermStructure *) x));
}
static void *_p_YoYInflationTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *) ((YoYInflationTermStructure *) x));
}
static void *_p_InflationTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((InflationTermStructure *) x));
}
static void *_p_YieldTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((YieldTermStructure *) x));
}
static void *_p_ImpliedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((ImpliedTermStructure *) x));
}
static void *_p_ZeroSpreadedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((ZeroSpreadedTermStructure *) x));
}
static void *_p_ForwardSpreadedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((ForwardSpreadedTermStructure *) x));
}
static void *_p_VolatilityTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((VolatilityTermStructure *) x));
}
static void *_p_BlackVolTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((BlackVolTermStructure *) x));
}
static void *_p_LocalVolTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((LocalVolTermStructure *) x));
}
static void *_p_OptionletVolatilityStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((OptionletVolatilityStructure *) x));
}
static void *_p_SwaptionVolatilityStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((SwaptionVolatilityStructure *) x));
}
static void *_p_PiecewiseConvexMonotoneZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseConvexMonotoneZero *) x));
}
static void *_p_DefaultProbabilityTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((DefaultProbabilityTermStructure *) x));
}
static void *_p_CapFloorTermVolatilityStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((CapFloorTermVolatilityStructure *) x));
}
static void *_p_FlatHazardRateTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((FlatHazardRate *) x));
}
static void *_p_PiecewiseFlatHazardRateTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((PiecewiseFlatHazardRate *) x));
}
static void *_p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *) x));
}
static void *_p_GlobalLinearSimpleZeroCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((GlobalLinearSimpleZeroCurve *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((SwaptionVolatilityDiscrete *) 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_CapFloorTermVolCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolCurve *) x));
}
static void *_p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *) x));
}
static void *_p_SwaptionVolCube1To_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube1 *) x));
}
static void *_p_SwaptionVolCube2To_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube2 *) x));
}
static void *_p_FlatForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((FlatForward *) x));
}
static void *_p_PiecewiseFlatForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseFlatForward *) x));
}
static void *_p_PiecewiseLogLinearDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLogLinearDiscount *) x));
}
static void *_p_PiecewiseLinearForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLinearForward *) x));
}
static void *_p_PiecewiseLogCubicDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLogCubicDiscount *) x));
}
static void *_p_PiecewiseSplineCubicDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseSplineCubicDiscount *) x));
}
static void *_p_PiecewiseKrugerLogDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseKrugerLogDiscount *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_AndreasenHugeVolatilityAdapterTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((AndreasenHugeVolatilityAdapter *) x));
}
static void *_p_AndreasenHugeLocalVolAdapterTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((AndreasenHugeLocalVolAdapter *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (OptionletVolatilityStructure *) ((StrippedOptionletAdapter *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (CapFloorTermVolatilityStructure *) ((CapFloorTermVolCurve *) x));
}
static void *_p_LocalConstantVolTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((LocalConstantVol *) 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_SwaptionVolCube1To_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube1 *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *) ((ConstantSwaptionVolatility *) x));
}
static void *_p_ConstantOptionletVolatilityTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (OptionletVolatilityStructure *) ((ConstantOptionletVolatility *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_SwaptionVolCube2To_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SwaptionVolCube2 *) x));
}
static void *_p_ConstantYoYOptionletVolatilityTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (YoYOptionletVolatilitySurface *) ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (YoYOptionletVolatilitySurface *) ((KInterpolatedYoYOptionletVolatilitySurface< Linear > *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (YoYOptionletVolatilitySurface *) ((InterpolatedYoYOptionletVolatilityCurve< Linear > *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *) ((SwaptionVolatilityDiscrete *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *)(LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_LocalVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((LocalVolSurface *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((BlackVarianceSurface *) x));
}
static void *_p_YoYOptionletVolatilitySurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((YoYOptionletVolatilitySurface *) x));
}
static void *_p_SwaptionVolatilityStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((SwaptionVolatilityStructure *) x));
}
static void *_p_OptionletVolatilityStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((OptionletVolatilityStructure *) x));
}
static void *_p_LocalVolTermStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((LocalVolTermStructure *) x));
}
static void *_p_BlackVolTermStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((BlackVolTermStructure *) x));
}
static void *_p_HestonBlackVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((HestonBlackVolSurface *) x));
}
static void *_p_CapFloorTermVolatilityStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((CapFloorTermVolatilityStructure *) x));
}
static void *_p_CapFloorTermVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (CapFloorTermVolatilityStructure *) ((CapFloorTermVolSurface *) x));
}
static void *_p_BlackConstantVolTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((BlackConstantVol *) 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_AndreasenHugeVolatilityAdapterTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((AndreasenHugeVolatilityAdapter *) x));
}
static void *_p_BlackVarianceCurveTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((BlackVarianceCurve *) 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_AndreasenHugeLocalVolAdapterTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *)  ((AndreasenHugeLocalVolAdapter *) x));
}
static void *_p_PiecewiseZeroInflationCurveT_Linear_tTo_p_ZeroInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationTermStructure *)  ((PiecewiseZeroInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroInflationCurveT_Linear_tTo_p_ZeroInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationTermStructure *)  ((InterpolatedZeroInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseYoYInflationCurveT_Linear_tTo_p_YoYInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationTermStructure *)  ((PiecewiseYoYInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedYoYInflationCurveT_Linear_tTo_p_YoYInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationTermStructure *)  ((InterpolatedYoYInflationCurve< Linear > *) 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_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_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_DefaultProbabilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityTermStructure *)  ((InterpolatedHazardRateCurve< BackwardFlat > *) x));
}
static void *_p_CapFloorTermVolSurfaceTo_p_CapFloorTermVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloorTermVolatilityStructure *)  ((CapFloorTermVolSurface *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_CapFloorTermVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloorTermVolatilityStructure *)  ((CapFloorTermVolCurve *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_BatesModelTo_p_HestonModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((HestonModel *)  ((BatesModel *) x));
}
static void *_p_SwaptionHelperTo_p_BlackCalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackCalibrationHelper *)  ((SwaptionHelper *) 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_BlackCalibrationHelperTo_p_CalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibrationHelper *)  ((BlackCalibrationHelper *) x));
}
static void *_p_SwaptionHelperTo_p_CalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibrationHelper *) (BlackCalibrationHelper *) ((SwaptionHelper *) 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_FixedRateBondHelperTo_p_BondHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BondHelper *)  ((FixedRateBondHelper *) 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_SvenssonFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((SvenssonFitting *) x));
}
static void *_p_CubicBSplinesFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((CubicBSplinesFitting *) x));
}
static void *_p_SimplePolynomialFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((SimplePolynomialFitting *) x));
}
static void *_p_QuantLib__ThailandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Thailand *) x));
}
static void *_p_QuantLib__NorwayTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Norway *) x));
}
static void *_p_QuantLib__NewZealandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::NewZealand *) x));
}
static void *_p_QuantLib__SwedenTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Sweden *) x));
}
static void *_p_QuantLib__GermanyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Germany *) x));
}
static void *_p_QuantLib__IsraelTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Israel *) x));
}
static void *_p_QuantLib__WeekendsOnlyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::WeekendsOnly *) x));
}
static void *_p_QuantLib__CanadaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Canada *) x));
}
static void *_p_QuantLib__PolandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Poland *) x));
}
static void *_p_QuantLib__HungaryTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Hungary *) x));
}
static void *_p_QuantLib__AustraliaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Australia *) x));
}
static void *_p_QuantLib__SwitzerlandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Switzerland *) x));
}
static void *_p_QuantLib__JapanTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Japan *) x));
}
static void *_p_QuantLib__BrazilTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Brazil *) x));
}
static void *_p_QuantLib__IcelandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Iceland *) x));
}
static void *_p_QuantLib__MexicoTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Mexico *) x));
}
static void *_p_QuantLib__CzechRepublicTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::CzechRepublic *) x));
}
static void *_p_QuantLib__IndonesiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Indonesia *) x));
}
static void *_p_QuantLib__SaudiArabiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::SaudiArabia *) x));
}
static void *_p_QuantLib__ChinaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::China *) x));
}
static void *_p_QuantLib__NullCalendarTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::NullCalendar *) x));
}
static void *_p_QuantLib__JointCalendarTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::JointCalendar *) x));
}
static void *_p_QuantLib__BespokeCalendarTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::BespokeCalendar *) x));
}
static void *_p_QuantLib__SouthKoreaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::SouthKorea *) x));
}
static void *_p_QuantLib__UnitedKingdomTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::UnitedKingdom *) x));
}
static void *_p_QuantLib__SingaporeTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Singapore *) x));
}
static void *_p_QuantLib__SouthAfricaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::SouthAfrica *) x));
}
static void *_p_QuantLib__ArgentinaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Argentina *) x));
}
static void *_p_QuantLib__RomaniaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Romania *) x));
}
static void *_p_QuantLib__TARGETTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::TARGET *) x));
}
static void *_p_QuantLib__SlovakiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Slovakia *) x));
}
static void *_p_QuantLib__RussiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Russia *) x));
}
static void *_p_QuantLib__UkraineTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Ukraine *) x));
}
static void *_p_QuantLib__FinlandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Finland *) x));
}
static void *_p_QuantLib__ItalyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Italy *) x));
}
static void *_p_QuantLib__IndiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::India *) x));
}
static void *_p_QuantLib__TaiwanTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Taiwan *) x));
}
static void *_p_QuantLib__UnitedStatesTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::UnitedStates *) x));
}
static void *_p_QuantLib__FranceTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::France *) x));
}
static void *_p_QuantLib__DenmarkTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Denmark *) x));
}
static void *_p_QuantLib__TurkeyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Turkey *) x));
}
static void *_p_QuantLib__HongKongTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::HongKong *) x));
}
static void *_p_QuantLib__Thirty360To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Thirty360 *) 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__Actual360To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual360 *) x));
}
static void *_p_QuantLib__Actual365FixedTo_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual365Fixed *) x));
}
static void *_p_QuantLib__Business252To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Business252 *) x));
}
static void *_p_QuantLib__Thirty365To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Thirty365 *) x));
}
static void *_p_QuantLib__ActualActualTo_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::ActualActual *) x));
}
static void *_p_QuantLib__Actual364To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual364 *) x));
}
static void *_p_Bbsw1MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw1M *) x));
}
static void *_p_Bbsw3MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw3M *) x));
}
static void *_p_Bbsw5MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw5M *) x));
}
static void *_p_Bbsw2MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw2M *) x));
}
static void *_p_Bbsw4MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw4M *) x));
}
static void *_p_Bbsw6MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw6M *) 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_Fdm2dBlackScholesOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((Fdm2dBlackScholesOp *) x));
}
static void *_p_FdmBlackScholesOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmBlackScholesOp *) 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_FdmLocalVolFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmLocalVolFwdOp *) x));
}
static void *_p_FdmLinearOpCompositeProxyTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmLinearOpCompositeProxy *) x));
}
static void *_p_FdmHullWhiteOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHullWhiteOp *) x));
}
static void *_p_FdmHestonHullWhiteOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHestonHullWhiteOp *) x));
}
static void *_p_FdmSabrOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmSabrOp *) x));
}
static void *_p_FdmHestonOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHestonOp *) x));
}
static void *_p_FdmHestonFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHestonFwdOp *) x));
}
static void *_p_FdmCEVOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmCEVOp *) x));
}
static void *_p_FdmG2OpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmG2Op *) x));
}
static void *_p_FdmBatesOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmBatesOp *) x));
}
static void *_p_FdmDupire1dOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmDupire1dOp *) x));
}
static void *_p_FdmOrnsteinUhlenbeckOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmOrnsteinUhlenbeckOp *) x));
}
static void *_p_FdmBlackScholesFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmBlackScholesFwdOp *) x));
}
static void *_p_LevenbergMarquardtTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((LevenbergMarquardt *) 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_MirrorGaussianSimulatedAnnealingTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((MirrorGaussianSimulatedAnnealing *) x));
}
static void *_p_LogNormalSimulatedAnnealingTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((LogNormalSimulatedAnnealing *) 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_ConjugateGradientTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((ConjugateGradient *) x));
}
static void *_p_BFGSTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((BFGS *) 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_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_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_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_AnalyticContinuousGeometricAveragePriceAsianEngine = {"_p_AnalyticContinuousGeometricAveragePriceAsianEngine", "AnalyticContinuousGeometricAveragePriceAsianEngine *", 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_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_AnalyticGJRGARCHEngine = {"_p_AnalyticGJRGARCHEngine", "AnalyticGJRGARCHEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticHaganPricer = {"_p_AnalyticHaganPricer", "AnalyticHaganPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticHestonEngine = {"_p_AnalyticHestonEngine", "AnalyticHestonEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticHestonEngine__Integration = {"_p_AnalyticHestonEngine__Integration", "AnalyticHestonEngine::Integration *|AnalyticPTDHestonEngine::Integration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticPTDHestonEngine = {"_p_AnalyticPTDHestonEngine", "AnalyticPTDHestonEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AndreasenHugeLocalVolAdapter = {"_p_AndreasenHugeLocalVolAdapter", "AndreasenHugeLocalVolAdapter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AndreasenHugeVolatilityAdapter = {"_p_AndreasenHugeVolatilityAdapter", "AndreasenHugeVolatilityAdapter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AndreasenHugeVolatilityInterpl = {"_p_AndreasenHugeVolatilityInterpl", "AndreasenHugeVolatilityInterpl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Aonia = {"_p_Aonia", "Aonia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Array = {"_p_Array", "Array *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AssetOrNothingPayoff = {"_p_AssetOrNothingPayoff", "AssetOrNothingPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AssetSwap = {"_p_AssetSwap", "AssetSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Average = {"_p_Average", "Average *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AverageBasketPayoff = {"_p_AverageBasketPayoff", "AverageBasketPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BFGS = {"_p_BFGS", "BFGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BSMRNDCalculator = {"_p_BSMRNDCalculator", "BSMRNDCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BachelierCapFloorEngine = {"_p_BachelierCapFloorEngine", "BachelierCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BachelierSwaptionEngine = {"_p_BachelierSwaptionEngine", "BachelierSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BackwardFlat = {"_p_BackwardFlat", "BackwardFlat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BaroneAdesiWhaleyApproximationEngine = {"_p_BaroneAdesiWhaleyApproximationEngine", "BaroneAdesiWhaleyApproximationEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Barrier = {"_p_Barrier", "Barrier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BarrierOption = {"_p_BarrierOption", "BarrierOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BasketOption = {"_p_BasketOption", "BasketOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BasketPayoff = {"_p_BasketPayoff", "BasketPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BatesEngine = {"_p_BatesEngine", "BatesEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BatesModel = {"_p_BatesModel", "BatesModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BatesProcess = {"_p_BatesProcess", "BatesProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw = {"_p_Bbsw", "Bbsw *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw1M = {"_p_Bbsw1M", "Bbsw1M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw2M = {"_p_Bbsw2M", "Bbsw2M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw3M = {"_p_Bbsw3M", "Bbsw3M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw4M = {"_p_Bbsw4M", "Bbsw4M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw5M = {"_p_Bbsw5M", "Bbsw5M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bbsw6M = {"_p_Bbsw6M", "Bbsw6M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BermudanExercise = {"_p_BermudanExercise", "BermudanExercise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BiCGstab = {"_p_BiCGstab", "BiCGstab *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor = {"_p_Bibor", "Bibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor1M = {"_p_Bibor1M", "Bibor1M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor1Y = {"_p_Bibor1Y", "Bibor1Y *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor2M = {"_p_Bibor2M", "Bibor2M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor3M = {"_p_Bibor3M", "Bibor3M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor6M = {"_p_Bibor6M", "Bibor6M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bibor9M = {"_p_Bibor9M", "Bibor9M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BiborSW = {"_p_BiborSW", "BiborSW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bicubic = {"_p_Bicubic", "Bicubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t = {"_p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t", "BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t = {"_p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t", "BinomialConvertibleEngine< AdditiveEQPBinomialTree > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_CoxRossRubinstein_t = {"_p_BinomialConvertibleEngineT_CoxRossRubinstein_t", "BinomialConvertibleEngine< CoxRossRubinstein > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_JarrowRudd_t = {"_p_BinomialConvertibleEngineT_JarrowRudd_t", "BinomialConvertibleEngine< JarrowRudd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_Joshi4_t = {"_p_BinomialConvertibleEngineT_Joshi4_t", "BinomialConvertibleEngine< Joshi4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_LeisenReimer_t = {"_p_BinomialConvertibleEngineT_LeisenReimer_t", "BinomialConvertibleEngine< LeisenReimer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_Tian_t = {"_p_BinomialConvertibleEngineT_Tian_t", "BinomialConvertibleEngine< Tian > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialConvertibleEngineT_Trigeorgis_t = {"_p_BinomialConvertibleEngineT_Trigeorgis_t", "BinomialConvertibleEngine< Trigeorgis > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDistribution = {"_p_BinomialDistribution", "BinomialDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t = {"_p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t", "BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t = {"_p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t", "BinomialVanillaEngine< AdditiveEQPBinomialTree > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_CoxRossRubinstein_t = {"_p_BinomialVanillaEngineT_CoxRossRubinstein_t", "BinomialVanillaEngine< CoxRossRubinstein > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_JarrowRudd_t = {"_p_BinomialVanillaEngineT_JarrowRudd_t", "BinomialVanillaEngine< JarrowRudd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_Joshi4_t = {"_p_BinomialVanillaEngineT_Joshi4_t", "BinomialVanillaEngine< Joshi4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_LeisenReimer_t = {"_p_BinomialVanillaEngineT_LeisenReimer_t", "BinomialVanillaEngine< LeisenReimer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_Tian_t = {"_p_BinomialVanillaEngineT_Tian_t", "BinomialVanillaEngine< Tian > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BinomialVanillaEngineT_Trigeorgis_t = {"_p_BinomialVanillaEngineT_Trigeorgis_t", "BinomialVanillaEngine< Trigeorgis > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bisection = {"_p_Bisection", "Bisection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BivariateCumulativeNormalDistribution = {"_p_BivariateCumulativeNormalDistribution", "BivariateCumulativeNormalDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BivariateCumulativeNormalDistributionDr78 = {"_p_BivariateCumulativeNormalDistributionDr78", "BivariateCumulativeNormalDistributionDr78 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BivariateCumulativeNormalDistributionWe04DP = {"_p_BivariateCumulativeNormalDistributionWe04DP", "BivariateCumulativeNormalDistributionWe04DP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BjerksundStenslandApproximationEngine = {"_p_BjerksundStenslandApproximationEngine", "BjerksundStenslandApproximationEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm = {"_p_Bkbm", "Bkbm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm1M = {"_p_Bkbm1M", "Bkbm1M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm2M = {"_p_Bkbm2M", "Bkbm2M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm3M = {"_p_Bkbm3M", "Bkbm3M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm4M = {"_p_Bkbm4M", "Bkbm4M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm5M = {"_p_Bkbm5M", "Bkbm5M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bkbm6M = {"_p_Bkbm6M", "Bkbm6M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackCalculator = {"_p_BlackCalculator", "BlackCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackCalibrationHelper = {"_p_BlackCalibrationHelper", "BlackCalibrationHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackCallableFixedRateBondEngine = {"_p_BlackCallableFixedRateBondEngine", "BlackCallableFixedRateBondEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackCapFloorEngine = {"_p_BlackCapFloorEngine", "BlackCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackCdsOptionEngine = {"_p_BlackCdsOptionEngine", "BlackCdsOptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackConstantVol = {"_p_BlackConstantVol", "BlackConstantVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackDeltaCalculator = {"_p_BlackDeltaCalculator", "BlackDeltaCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackIborCouponPricer = {"_p_BlackIborCouponPricer", "BlackIborCouponPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackKarasinski = {"_p_BlackKarasinski", "BlackKarasinski *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackProcess = {"_p_BlackProcess", "BlackProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackScholesMertonProcess = {"_p_BlackScholesMertonProcess", "BlackScholesMertonProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackScholesProcess = {"_p_BlackScholesProcess", "BlackScholesProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackSwaptionEngine = {"_p_BlackSwaptionEngine", "BlackSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackVarianceCurve = {"_p_BlackVarianceCurve", "BlackVarianceCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackVarianceSurface = {"_p_BlackVarianceSurface", "BlackVarianceSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BlackVolTermStructure = {"_p_BlackVolTermStructure", "BlackVolTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Bond = {"_p_Bond", "Bond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BondFunctions = {"_p_BondFunctions", "BondFunctions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BondHelper = {"_p_BondHelper", "BondHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BootstrapHelperT_YoYInflationTermStructure_t = {"_p_BootstrapHelperT_YoYInflationTermStructure_t", "BootstrapHelper< YoYInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BootstrapHelperT_YoYOptionletVolatilitySurface_t = {"_p_BootstrapHelperT_YoYOptionletVolatilitySurface_t", "BootstrapHelper< YoYOptionletVolatilitySurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BootstrapHelperT_ZeroInflationTermStructure_t = {"_p_BootstrapHelperT_ZeroInflationTermStructure_t", "BootstrapHelper< ZeroInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoundaryConstraint = {"_p_BoundaryConstraint", "BoundaryConstraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoxMullerGaussianRngT_KnuthUniformRng_t = {"_p_BoxMullerGaussianRngT_KnuthUniformRng_t", "BoxMullerGaussianRng< KnuthUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoxMullerGaussianRngT_LecuyerUniformRng_t = {"_p_BoxMullerGaussianRngT_LecuyerUniformRng_t", "BoxMullerGaussianRng< LecuyerUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t = {"_p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t", "BoxMullerGaussianRng< MersenneTwisterUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Brent = {"_p_Brent", "Brent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BrownianBridge = {"_p_BrownianBridge", "BrownianBridge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BrownianGeneratorFactory = {"_p_BrownianGeneratorFactory", "BrownianGeneratorFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CADLibor = {"_p_CADLibor", "CADLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CADLiborON = {"_p_CADLiborON", "CADLiborON *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CEVRNDCalculator = {"_p_CEVRNDCalculator", "CEVRNDCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CHFLibor = {"_p_CHFLibor", "CHFLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CLGaussianRngT_KnuthUniformRng_t = {"_p_CLGaussianRngT_KnuthUniformRng_t", "CLGaussianRng< KnuthUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CLGaussianRngT_LecuyerUniformRng_t = {"_p_CLGaussianRngT_LecuyerUniformRng_t", "CLGaussianRng< LecuyerUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CLGaussianRngT_MersenneTwisterUniformRng_t = {"_p_CLGaussianRngT_MersenneTwisterUniformRng_t", "CLGaussianRng< MersenneTwisterUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_COSHestonEngine = {"_p_COSHestonEngine", "COSHestonEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CPI = {"_p_CPI", "CPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CPIBond = {"_p_CPIBond", "CPIBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CPICoupon = {"_p_CPICoupon", "CPICoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CPISwap = {"_p_CPISwap", "CPISwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Calendar = {"_p_Calendar", "Calendar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CalibratedModel = {"_p_CalibratedModel", "CalibratedModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CalibrationHelper = {"_p_CalibrationHelper", "CalibrationHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CalibrationSet = {"_p_CalibrationSet", "CalibrationSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Callability = {"_p_Callability", "Callability *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CallabilityPrice = {"_p_CallabilityPrice", "CallabilityPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CallableBond = {"_p_CallableBond", "CallableBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CallableFixedRateBond = {"_p_CallableFixedRateBond", "CallableFixedRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CallableZeroCouponBond = {"_p_CallableZeroCouponBond", "CallableZeroCouponBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Cap = {"_p_Cap", "Cap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CapFloor = {"_p_CapFloor", "CapFloor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CapFloorTermVolCurve = {"_p_CapFloorTermVolCurve", "CapFloorTermVolCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CapFloorTermVolSurface = {"_p_CapFloorTermVolSurface", "CapFloorTermVolSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CapFloorTermVolatilityStructure = {"_p_CapFloorTermVolatilityStructure", "CapFloorTermVolatilityStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CapHelper = {"_p_CapHelper", "CapHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CappedFlooredCmsCoupon = {"_p_CappedFlooredCmsCoupon", "CappedFlooredCmsCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CappedFlooredCmsSpreadCoupon = {"_p_CappedFlooredCmsSpreadCoupon", "CappedFlooredCmsSpreadCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CappedFlooredCoupon = {"_p_CappedFlooredCoupon", "CappedFlooredCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CappedFlooredIborCoupon = {"_p_CappedFlooredIborCoupon", "CappedFlooredIborCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CashFlow = {"_p_CashFlow", "CashFlow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CashFlows = {"_p_CashFlows", "CashFlows *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CashOrNothingPayoff = {"_p_CashOrNothingPayoff", "CashOrNothingPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Cdor = {"_p_Cdor", "Cdor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CdsOption = {"_p_CdsOption", "CdsOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CeilingTruncation = {"_p_CeilingTruncation", "CeilingTruncation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChfLiborSwapIsdaFix = {"_p_ChfLiborSwapIsdaFix", "ChfLiborSwapIsdaFix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Claim = {"_p_Claim", "Claim *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ClosestRounding = {"_p_ClosestRounding", "ClosestRounding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsCoupon = {"_p_CmsCoupon", "CmsCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsCouponPricer = {"_p_CmsCouponPricer", "CmsCouponPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsMarket = {"_p_CmsMarket", "CmsMarket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsMarketCalibration = {"_p_CmsMarketCalibration", "CmsMarketCalibration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsRateBond = {"_p_CmsRateBond", "CmsRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsSpreadCoupon = {"_p_CmsSpreadCoupon", "CmsSpreadCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CmsSpreadCouponPricer = {"_p_CmsSpreadCouponPricer", "CmsSpreadCouponPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Collar = {"_p_Collar", "Collar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CompositeConstraint = {"_p_CompositeConstraint", "CompositeConstraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CompositeInstrument = {"_p_CompositeInstrument", "CompositeInstrument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CompositeQuoteT_BinaryFunction_t = {"_p_CompositeQuoteT_BinaryFunction_t", "CompositeQuote< BinaryFunction > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Concentrating1dMesher = {"_p_Concentrating1dMesher", "Concentrating1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Conditions = {"_p_Conditions", "Conditions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConjugateGradient = {"_p_ConjugateGradient", "ConjugateGradient *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstantEstimator = {"_p_ConstantEstimator", "ConstantEstimator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstantOptionletVolatility = {"_p_ConstantOptionletVolatility", "ConstantOptionletVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstantParameter = {"_p_ConstantParameter", "ConstantParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstantSwaptionVolatility = {"_p_ConstantSwaptionVolatility", "ConstantSwaptionVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstantYoYOptionletVolatility = {"_p_ConstantYoYOptionletVolatility", "ConstantYoYOptionletVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Constraint = {"_p_Constraint", "Constraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContinuousArithmeticAsianLevyEngine = {"_p_ContinuousArithmeticAsianLevyEngine", "ContinuousArithmeticAsianLevyEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContinuousAveragingAsianOption = {"_p_ContinuousAveragingAsianOption", "ContinuousAveragingAsianOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConvertibleFixedCouponBond = {"_p_ConvertibleFixedCouponBond", "ConvertibleFixedCouponBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConvertibleFloatingRateBond = {"_p_ConvertibleFloatingRateBond", "ConvertibleFloatingRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConvertibleZeroCouponBond = {"_p_ConvertibleZeroCouponBond", "ConvertibleZeroCouponBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConvexMonotone = {"_p_ConvexMonotone", "ConvexMonotone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Coupon = {"_p_Coupon", "Coupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CoxIngersollRoss = {"_p_CoxIngersollRoss", "CoxIngersollRoss *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CraigSneydScheme = {"_p_CraigSneydScheme", "CraigSneydScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CrankNicolsonScheme = {"_p_CrankNicolsonScheme", "CrankNicolsonScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CreditDefaultSwap = {"_p_CreditDefaultSwap", "CreditDefaultSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Cubic = {"_p_Cubic", "Cubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CubicBSplinesFitting = {"_p_CubicBSplinesFitting", "CubicBSplinesFitting *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CumulativeBinomialDistribution = {"_p_CumulativeBinomialDistribution", "CumulativeBinomialDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CumulativeChiSquareDistribution = {"_p_CumulativeChiSquareDistribution", "CumulativeChiSquareDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CumulativeGammaDistribution = {"_p_CumulativeGammaDistribution", "CumulativeGammaDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CumulativeNormalDistribution = {"_p_CumulativeNormalDistribution", "CumulativeNormalDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CumulativePoissonDistribution = {"_p_CumulativePoissonDistribution", "CumulativePoissonDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CumulativeStudentDistribution = {"_p_CumulativeStudentDistribution", "CumulativeStudentDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Currency = {"_p_Currency", "Currency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CustomRegion = {"_p_CustomRegion", "CustomRegion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DKKLibor = {"_p_DKKLibor", "DKKLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DMinus = {"_p_DMinus", "DMinus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DPlus = {"_p_DPlus", "DPlus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DPlusDMinus = {"_p_DPlusDMinus", "DPlusDMinus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DZero = {"_p_DZero", "DZero *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DailyTenorLibor = {"_p_DailyTenorLibor", "DailyTenorLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Date = {"_p_Date", "std::map< double,Date >::mapped_type *|std::vector< Date >::value_type *|Date *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DateGeneration = {"_p_DateGeneration", "DateGeneration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DateParser = {"_p_DateParser", "DateParser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DatedOISRateHelper = {"_p_DatedOISRateHelper", "DatedOISRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DayCounter = {"_p_DayCounter", "DayCounter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultBoundaryCondition = {"_p_DefaultBoundaryCondition", "DefaultBoundaryCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultDensity = {"_p_DefaultDensity", "DefaultDensity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultLexicographicalView = {"_p_DefaultLexicographicalView", "DefaultLexicographicalView *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultLexicographicalViewColumn = {"_p_DefaultLexicographicalViewColumn", "DefaultLexicographicalViewColumn *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultLogCubic = {"_p_DefaultLogCubic", "DefaultLogCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultProbabilityHelper = {"_p_DefaultProbabilityHelper", "DefaultProbabilityHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefaultProbabilityTermStructure = {"_p_DefaultProbabilityTermStructure", "DefaultProbabilityTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DeltaVolQuote = {"_p_DeltaVolQuote", "DeltaVolQuote *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DepositRateHelper = {"_p_DepositRateHelper", "DepositRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DerivedQuoteT_UnaryFunction_t = {"_p_DerivedQuoteT_UnaryFunction_t", "DerivedQuote< UnaryFunction > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DifferentialEvolution = {"_p_DifferentialEvolution", "DifferentialEvolution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DirichletBC = {"_p_DirichletBC", "DirichletBC *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Discount = {"_p_Discount", "Discount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DiscountingBondEngine = {"_p_DiscountingBondEngine", "DiscountingBondEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DiscountingSwapEngine = {"_p_DiscountingSwapEngine", "DiscountingSwapEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DiscreteAveragingAsianOption = {"_p_DiscreteAveragingAsianOption", "DiscreteAveragingAsianOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DisposableT_Array_t = {"_p_DisposableT_Array_t", "Disposable< Array > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dividend = {"_p_Dividend", "Dividend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DividendBarrierOption = {"_p_DividendBarrierOption", "DividendBarrierOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DividendVanillaOption = {"_p_DividendVanillaOption", "DividendVanillaOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DoubleBarrier = {"_p_DoubleBarrier", "DoubleBarrier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DoubleBarrierOption = {"_p_DoubleBarrierOption", "DoubleBarrierOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DouglasScheme = {"_p_DouglasScheme", "DouglasScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DownRounding = {"_p_DownRounding", "DownRounding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Duration = {"_p_Duration", "Duration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EUHICP = {"_p_EUHICP", "EUHICP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EUHICPXT = {"_p_EUHICPXT", "EUHICPXT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor = {"_p_EURLibor", "EURLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor10M = {"_p_EURLibor10M", "EURLibor10M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor11M = {"_p_EURLibor11M", "EURLibor11M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor1M = {"_p_EURLibor1M", "EURLibor1M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor1Y = {"_p_EURLibor1Y", "EURLibor1Y *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor2M = {"_p_EURLibor2M", "EURLibor2M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor2W = {"_p_EURLibor2W", "EURLibor2W *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor3M = {"_p_EURLibor3M", "EURLibor3M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor4M = {"_p_EURLibor4M", "EURLibor4M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor5M = {"_p_EURLibor5M", "EURLibor5M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor6M = {"_p_EURLibor6M", "EURLibor6M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor7M = {"_p_EURLibor7M", "EURLibor7M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor8M = {"_p_EURLibor8M", "EURLibor8M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLibor9M = {"_p_EURLibor9M", "EURLibor9M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EURLiborSW = {"_p_EURLiborSW", "EURLiborSW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EndCriteria = {"_p_EndCriteria", "EndCriteria *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EndCriteria__Type = {"_p_EndCriteria__Type", "enum EndCriteria::Type *|EndCriteria::Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Eonia = {"_p_Eonia", "Eonia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EurLiborSwapIfrFix = {"_p_EurLiborSwapIfrFix", "EurLiborSwapIfrFix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EurLiborSwapIsdaFixA = {"_p_EurLiborSwapIsdaFixA", "EurLiborSwapIsdaFixA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EurLiborSwapIsdaFixB = {"_p_EurLiborSwapIsdaFixB", "EurLiborSwapIsdaFixB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor = {"_p_Euribor", "Euribor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor10M = {"_p_Euribor10M", "Euribor10M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor11M = {"_p_Euribor11M", "Euribor11M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor1M = {"_p_Euribor1M", "Euribor1M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor1Y = {"_p_Euribor1Y", "Euribor1Y *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor2M = {"_p_Euribor2M", "Euribor2M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor2W = {"_p_Euribor2W", "Euribor2W *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365 = {"_p_Euribor365", "Euribor365 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_10M = {"_p_Euribor365_10M", "Euribor365_10M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_11M = {"_p_Euribor365_11M", "Euribor365_11M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_1M = {"_p_Euribor365_1M", "Euribor365_1M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_1Y = {"_p_Euribor365_1Y", "Euribor365_1Y *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_2M = {"_p_Euribor365_2M", "Euribor365_2M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_2W = {"_p_Euribor365_2W", "Euribor365_2W *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_3M = {"_p_Euribor365_3M", "Euribor365_3M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_3W = {"_p_Euribor365_3W", "Euribor365_3W *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_4M = {"_p_Euribor365_4M", "Euribor365_4M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_5M = {"_p_Euribor365_5M", "Euribor365_5M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_6M = {"_p_Euribor365_6M", "Euribor365_6M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_7M = {"_p_Euribor365_7M", "Euribor365_7M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_8M = {"_p_Euribor365_8M", "Euribor365_8M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_9M = {"_p_Euribor365_9M", "Euribor365_9M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor365_SW = {"_p_Euribor365_SW", "Euribor365_SW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor3M = {"_p_Euribor3M", "Euribor3M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor3W = {"_p_Euribor3W", "Euribor3W *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor4M = {"_p_Euribor4M", "Euribor4M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor5M = {"_p_Euribor5M", "Euribor5M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor6M = {"_p_Euribor6M", "Euribor6M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor7M = {"_p_Euribor7M", "Euribor7M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor8M = {"_p_Euribor8M", "Euribor8M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Euribor9M = {"_p_Euribor9M", "Euribor9M *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EuriborSW = {"_p_EuriborSW", "EuriborSW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EuriborSwapIfrFix = {"_p_EuriborSwapIfrFix", "EuriborSwapIfrFix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EuriborSwapIsdaFixA = {"_p_EuriborSwapIsdaFixA", "EuriborSwapIsdaFixA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EuriborSwapIsdaFixB = {"_p_EuriborSwapIsdaFixB", "EuriborSwapIsdaFixB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EuropeanExercise = {"_p_EuropeanExercise", "EuropeanExercise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EuropeanOption = {"_p_EuropeanOption", "EuropeanOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EverestOption = {"_p_EverestOption", "EverestOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExchangeRate = {"_p_ExchangeRate", "ExchangeRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExchangeRateManager = {"_p_ExchangeRateManager", "ExchangeRateManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Exercise = {"_p_Exercise", "Exercise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExplicitEulerScheme = {"_p_ExplicitEulerScheme", "ExplicitEulerScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExponentialFittingHestonEngine = {"_p_ExponentialFittingHestonEngine", "ExponentialFittingHestonEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExponentialJump1dMesher = {"_p_ExponentialJump1dMesher", "ExponentialJump1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExponentialSplinesFitting = {"_p_ExponentialSplinesFitting", "ExponentialSplinesFitting *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExtOUWithJumpsProcess = {"_p_ExtOUWithJumpsProcess", "ExtOUWithJumpsProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExtendedCoxIngersollRoss = {"_p_ExtendedCoxIngersollRoss", "ExtendedCoxIngersollRoss *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExtendedOrnsteinUhlenbeckProcess = {"_p_ExtendedOrnsteinUhlenbeckProcess", "ExtendedOrnsteinUhlenbeckProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FDAmericanEngineT_CrankNicolson_t = {"_p_FDAmericanEngineT_CrankNicolson_t", "FDAmericanEngine< CrankNicolson > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FDBermudanEngineT_CrankNicolson_t = {"_p_FDBermudanEngineT_CrankNicolson_t", "FDBermudanEngine< CrankNicolson > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FDDividendAmericanEngineT_CrankNicolson_t = {"_p_FDDividendAmericanEngineT_CrankNicolson_t", "FDDividendAmericanEngine< CrankNicolson > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FDDividendEuropeanEngineT_CrankNicolson_t = {"_p_FDDividendEuropeanEngineT_CrankNicolson_t", "FDDividendEuropeanEngine< CrankNicolson > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FDEuropeanEngineT_CrankNicolson_t = {"_p_FDEuropeanEngineT_CrankNicolson_t", "FDEuropeanEngine< CrankNicolson > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FDShoutEngineT_CrankNicolson_t = {"_p_FDShoutEngineT_CrankNicolson_t", "FDShoutEngine< CrankNicolson > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FFTVarianceGammaEngine = {"_p_FFTVarianceGammaEngine", "FFTVarianceGammaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FRHICP = {"_p_FRHICP", "FRHICP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FaceValueAccrualClaim = {"_p_FaceValueAccrualClaim", "FaceValueAccrualClaim *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FaceValueClaim = {"_p_FaceValueClaim", "FaceValueClaim *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FalsePosition = {"_p_FalsePosition", "FalsePosition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fd2dBlackScholesVanillaEngine = {"_p_Fd2dBlackScholesVanillaEngine", "Fd2dBlackScholesVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdBatesVanillaEngine = {"_p_FdBatesVanillaEngine", "FdBatesVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdBlackScholesAsianEngine = {"_p_FdBlackScholesAsianEngine", "FdBlackScholesAsianEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdBlackScholesBarrierEngine = {"_p_FdBlackScholesBarrierEngine", "FdBlackScholesBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdBlackScholesRebateEngine = {"_p_FdBlackScholesRebateEngine", "FdBlackScholesRebateEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdBlackScholesVanillaEngine = {"_p_FdBlackScholesVanillaEngine", "FdBlackScholesVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdCEVVanillaEngine = {"_p_FdCEVVanillaEngine", "FdCEVVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdG2SwaptionEngine = {"_p_FdG2SwaptionEngine", "FdG2SwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdHestonBarrierEngine = {"_p_FdHestonBarrierEngine", "FdHestonBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdHestonDoubleBarrierEngine = {"_p_FdHestonDoubleBarrierEngine", "FdHestonDoubleBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdHestonRebateEngine = {"_p_FdHestonRebateEngine", "FdHestonRebateEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdHestonVanillaEngine = {"_p_FdHestonVanillaEngine", "FdHestonVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdHullWhiteSwaptionEngine = {"_p_FdHullWhiteSwaptionEngine", "FdHullWhiteSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdOrnsteinUhlenbeckVanillaEngine = {"_p_FdOrnsteinUhlenbeckVanillaEngine", "FdOrnsteinUhlenbeckVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdSabrVanillaEngine = {"_p_FdSabrVanillaEngine", "FdSabrVanillaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdSimpleBSSwingEngine = {"_p_FdSimpleBSSwingEngine", "FdSimpleBSSwingEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdSimpleExtOUJumpSwingEngine = {"_p_FdSimpleExtOUJumpSwingEngine", "FdSimpleExtOUJumpSwingEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fdm1DimSolver = {"_p_Fdm1DimSolver", "Fdm1DimSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fdm1dMesher = {"_p_Fdm1dMesher", "Fdm1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fdm2DimSolver = {"_p_Fdm2DimSolver", "Fdm2DimSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fdm2dBlackScholesOp = {"_p_Fdm2dBlackScholesOp", "Fdm2dBlackScholesOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fdm2dBlackScholesSolver = {"_p_Fdm2dBlackScholesSolver", "Fdm2dBlackScholesSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fdm3DimSolver = {"_p_Fdm3DimSolver", "Fdm3DimSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmAffineModelSwapInnerValueT_G2_t = {"_p_FdmAffineModelSwapInnerValueT_G2_t", "FdmAffineModelSwapInnerValue< G2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmAffineModelSwapInnerValueT_HullWhite_t = {"_p_FdmAffineModelSwapInnerValueT_HullWhite_t", "FdmAffineModelSwapInnerValue< HullWhite > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmAmericanStepCondition = {"_p_FdmAmericanStepCondition", "FdmAmericanStepCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmArithmeticAverageCondition = {"_p_FdmArithmeticAverageCondition", "FdmArithmeticAverageCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBackwardSolver = {"_p_FdmBackwardSolver", "FdmBackwardSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBatesOp = {"_p_FdmBatesOp", "FdmBatesOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBermudanStepCondition = {"_p_FdmBermudanStepCondition", "FdmBermudanStepCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBlackScholesFwdOp = {"_p_FdmBlackScholesFwdOp", "FdmBlackScholesFwdOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBlackScholesMesher = {"_p_FdmBlackScholesMesher", "FdmBlackScholesMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBlackScholesOp = {"_p_FdmBlackScholesOp", "FdmBlackScholesOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmBoundaryCondition = {"_p_FdmBoundaryCondition", "FdmBoundaryCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmCEV1dMesher = {"_p_FdmCEV1dMesher", "FdmCEV1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmCEVOp = {"_p_FdmCEVOp", "FdmCEVOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmCellAveragingInnerValue = {"_p_FdmCellAveragingInnerValue", "FdmCellAveragingInnerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmDirichletBoundary = {"_p_FdmDirichletBoundary", "FdmDirichletBoundary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmDiscountDirichletBoundary = {"_p_FdmDiscountDirichletBoundary", "FdmDiscountDirichletBoundary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmDividendHandler = {"_p_FdmDividendHandler", "FdmDividendHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmDupire1dOp = {"_p_FdmDupire1dOp", "FdmDupire1dOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmG2Op = {"_p_FdmG2Op", "FdmG2Op *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmG2Solver = {"_p_FdmG2Solver", "FdmG2Solver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonFwdOp = {"_p_FdmHestonFwdOp", "FdmHestonFwdOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonGreensFct = {"_p_FdmHestonGreensFct", "FdmHestonGreensFct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonHullWhiteOp = {"_p_FdmHestonHullWhiteOp", "FdmHestonHullWhiteOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonHullWhiteSolver = {"_p_FdmHestonHullWhiteSolver", "FdmHestonHullWhiteSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonLocalVolatilityVarianceMesher = {"_p_FdmHestonLocalVolatilityVarianceMesher", "FdmHestonLocalVolatilityVarianceMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonOp = {"_p_FdmHestonOp", "FdmHestonOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonSolver = {"_p_FdmHestonSolver", "FdmHestonSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHestonVarianceMesher = {"_p_FdmHestonVarianceMesher", "FdmHestonVarianceMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHullWhiteOp = {"_p_FdmHullWhiteOp", "FdmHullWhiteOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmHullWhiteSolver = {"_p_FdmHullWhiteSolver", "FdmHullWhiteSolver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmIndicesOnBoundary = {"_p_FdmIndicesOnBoundary", "FdmIndicesOnBoundary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmInnerValueCalculator = {"_p_FdmInnerValueCalculator", "FdmInnerValueCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmInnerValueCalculatorProxy = {"_p_FdmInnerValueCalculatorProxy", "FdmInnerValueCalculatorProxy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLinearOp = {"_p_FdmLinearOp", "FdmLinearOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLinearOpComposite = {"_p_FdmLinearOpComposite", "FdmLinearOpComposite *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLinearOpCompositeProxy = {"_p_FdmLinearOpCompositeProxy", "FdmLinearOpCompositeProxy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLinearOpIterator = {"_p_FdmLinearOpIterator", "FdmLinearOpIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLinearOpLayout = {"_p_FdmLinearOpLayout", "FdmLinearOpLayout *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLocalVolFwdOp = {"_p_FdmLocalVolFwdOp", "FdmLocalVolFwdOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLogBasketInnerValue = {"_p_FdmLogBasketInnerValue", "FdmLogBasketInnerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmLogInnerValue = {"_p_FdmLogInnerValue", "FdmLogInnerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmMesher = {"_p_FdmMesher", "FdmMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmMesherComposite = {"_p_FdmMesherComposite", "FdmMesherComposite *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmNdimSolverT_4_t = {"_p_FdmNdimSolverT_4_t", "FdmNdimSolver< 4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmNdimSolverT_5_t = {"_p_FdmNdimSolverT_5_t", "FdmNdimSolver< 5 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmNdimSolverT_6_t = {"_p_FdmNdimSolverT_6_t", "FdmNdimSolver< 6 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmOrnsteinUhlenbeckOp = {"_p_FdmOrnsteinUhlenbeckOp", "FdmOrnsteinUhlenbeckOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmQuantoHelper = {"_p_FdmQuantoHelper", "FdmQuantoHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSabrOp = {"_p_FdmSabrOp", "FdmSabrOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSchemeDesc = {"_p_FdmSchemeDesc", "FdmSchemeDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSimpleProcess1dMesher = {"_p_FdmSimpleProcess1dMesher", "FdmSimpleProcess1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSimpleStorageCondition = {"_p_FdmSimpleStorageCondition", "FdmSimpleStorageCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSimpleSwingCondition = {"_p_FdmSimpleSwingCondition", "FdmSimpleSwingCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSnapshotCondition = {"_p_FdmSnapshotCondition", "FdmSnapshotCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSolverDesc = {"_p_FdmSolverDesc", "FdmSolverDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmSquareRootFwdOp = {"_p_FdmSquareRootFwdOp", "FdmSquareRootFwdOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmStepConditionComposite = {"_p_FdmStepConditionComposite", "FdmStepConditionComposite *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmStepConditionProxy = {"_p_FdmStepConditionProxy", "FdmStepConditionProxy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmTimeDepDirichletBoundary = {"_p_FdmTimeDepDirichletBoundary", "FdmTimeDepDirichletBoundary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmZabrOp = {"_p_FdmZabrOp", "FdmZabrOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FdmZeroInnerValue = {"_p_FdmZeroInnerValue", "FdmZeroInnerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FedFunds = {"_p_FedFunds", "FedFunds *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FirstDerivativeOp = {"_p_FirstDerivativeOp", "FirstDerivativeOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FittedBondDiscountCurve = {"_p_FittedBondDiscountCurve", "FittedBondDiscountCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FittingMethod = {"_p_FittingMethod", "FittingMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FixedDividend = {"_p_FixedDividend", "FixedDividend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FixedRateBond = {"_p_FixedRateBond", "FixedRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FixedRateBondForward = {"_p_FixedRateBondForward", "FixedRateBondForward *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FixedRateBondHelper = {"_p_FixedRateBondHelper", "FixedRateBondHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FixedRateCoupon = {"_p_FixedRateCoupon", "FixedRateCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FlatForward = {"_p_FlatForward", "FlatForward *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FlatHazardRate = {"_p_FlatHazardRate", "FlatHazardRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FlatSmileSection = {"_p_FlatSmileSection", "FlatSmileSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FloatFloatSwap = {"_p_FloatFloatSwap", "FloatFloatSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FloatFloatSwaption = {"_p_FloatFloatSwaption", "FloatFloatSwaption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FloatingRateBond = {"_p_FloatingRateBond", "FloatingRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FloatingRateCoupon = {"_p_FloatingRateCoupon", "FloatingRateCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FloatingRateCouponPricer = {"_p_FloatingRateCouponPricer", "FloatingRateCouponPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Floor = {"_p_Floor", "Floor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FloorTruncation = {"_p_FloorTruncation", "FloorTruncation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Forward = {"_p_Forward", "Forward *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ForwardEuropeanEngine = {"_p_ForwardEuropeanEngine", "ForwardEuropeanEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ForwardFlat = {"_p_ForwardFlat", "ForwardFlat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ForwardRate = {"_p_ForwardRate", "ForwardRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ForwardRateAgreement = {"_p_ForwardRateAgreement", "ForwardRateAgreement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ForwardSpreadedTermStructure = {"_p_ForwardSpreadedTermStructure", "ForwardSpreadedTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ForwardVanillaOption = {"_p_ForwardVanillaOption", "ForwardVanillaOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FraRateHelper = {"_p_FraRateHelper", "FraRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FractionalDividend = {"_p_FractionalDividend", "FractionalDividend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Futures = {"_p_Futures", "Futures *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FuturesRateHelper = {"_p_FuturesRateHelper", "FuturesRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FxSwapRateHelper = {"_p_FxSwapRateHelper", "FxSwapRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_G2 = {"_p_G2", "G2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_G2ForwardProcess = {"_p_G2ForwardProcess", "G2ForwardProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_G2Process = {"_p_G2Process", "G2Process *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_G2SwaptionEngine = {"_p_G2SwaptionEngine", "G2SwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GBPLibor = {"_p_GBPLibor", "GBPLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GBPLiborON = {"_p_GBPLiborON", "GBPLiborON *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GBSMRNDCalculator = {"_p_GBSMRNDCalculator", "GBSMRNDCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GFunctionFactory = {"_p_GFunctionFactory", "GFunctionFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GJRGARCHModel = {"_p_GJRGARCHModel", "GJRGARCHModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GJRGARCHProcess = {"_p_GJRGARCHProcess", "GJRGARCHProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GMRES = {"_p_GMRES", "GMRES *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GammaFunction = {"_p_GammaFunction", "GammaFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GapPayoff = {"_p_GapPayoff", "GapPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GarmanKlassSigma1 = {"_p_GarmanKlassSigma1", "GarmanKlassSigma1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GarmanKlassSigma3 = {"_p_GarmanKlassSigma3", "GarmanKlassSigma3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GarmanKlassSigma4 = {"_p_GarmanKlassSigma4", "GarmanKlassSigma4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GarmanKlassSigma5 = {"_p_GarmanKlassSigma5", "GarmanKlassSigma5 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GarmanKlassSigma6 = {"_p_GarmanKlassSigma6", "GarmanKlassSigma6 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GarmanKohlagenProcess = {"_p_GarmanKohlagenProcess", "GarmanKohlagenProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussChebyshev2ndIntegration = {"_p_GaussChebyshev2ndIntegration", "GaussChebyshev2ndIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussChebyshevIntegration = {"_p_GaussChebyshevIntegration", "GaussChebyshevIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussGegenbauerIntegration = {"_p_GaussGegenbauerIntegration", "GaussGegenbauerIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussHermiteIntegration = {"_p_GaussHermiteIntegration", "GaussHermiteIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussHyperbolicIntegration = {"_p_GaussHyperbolicIntegration", "GaussHyperbolicIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussJacobiIntegration = {"_p_GaussJacobiIntegration", "GaussJacobiIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussKronrodAdaptive = {"_p_GaussKronrodAdaptive", "GaussKronrodAdaptive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussKronrodNonAdaptive = {"_p_GaussKronrodNonAdaptive", "GaussKronrodNonAdaptive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussLaguerreIntegration = {"_p_GaussLaguerreIntegration", "GaussLaguerreIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussLegendreIntegration = {"_p_GaussLegendreIntegration", "GaussLegendreIntegration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussLobattoIntegral = {"_p_GaussLobattoIntegral", "GaussLobattoIntegral *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Gaussian1dFloatFloatSwaptionEngine = {"_p_Gaussian1dFloatFloatSwaptionEngine", "Gaussian1dFloatFloatSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Gaussian1dJamshidianSwaptionEngine = {"_p_Gaussian1dJamshidianSwaptionEngine", "Gaussian1dJamshidianSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Gaussian1dModel = {"_p_Gaussian1dModel", "Gaussian1dModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Gaussian1dNonstandardSwaptionEngine = {"_p_Gaussian1dNonstandardSwaptionEngine", "Gaussian1dNonstandardSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Gaussian1dSwaptionEngine = {"_p_Gaussian1dSwaptionEngine", "Gaussian1dSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussianLowDiscrepancySequenceGenerator = {"_p_GaussianLowDiscrepancySequenceGenerator", "GaussianLowDiscrepancySequenceGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussianMultiPathGenerator = {"_p_GaussianMultiPathGenerator", "GaussianMultiPathGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussianRandomGenerator = {"_p_GaussianRandomGenerator", "GaussianRandomGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussianRandomSequenceGenerator = {"_p_GaussianRandomSequenceGenerator", "GaussianRandomSequenceGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GaussianSimulatedAnnealing = {"_p_GaussianSimulatedAnnealing", "GaussianSimulatedAnnealing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GbpLiborSwapIsdaFix = {"_p_GbpLiborSwapIsdaFix", "GbpLiborSwapIsdaFix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GeneralizedBlackScholesProcess = {"_p_GeneralizedBlackScholesProcess", "GeneralizedBlackScholesProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GenericSequenceStatisticsT_IncrementalStatistics_t = {"_p_GenericSequenceStatisticsT_IncrementalStatistics_t", "GenericSequenceStatistics< IncrementalStatistics > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GenericSequenceStatisticsT_RiskStatistics_t = {"_p_GenericSequenceStatisticsT_RiskStatistics_t", "GenericSequenceStatistics< RiskStatistics > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GenericSequenceStatisticsT_Statistics_t = {"_p_GenericSequenceStatisticsT_Statistics_t", "GenericSequenceStatistics< Statistics > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GeometricBrownianMotionProcess = {"_p_GeometricBrownianMotionProcess", "GeometricBrownianMotionProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GlobalLinearSimpleZeroCurve = {"_p_GlobalLinearSimpleZeroCurve", "GlobalLinearSimpleZeroCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Glued1dMesher = {"_p_Glued1dMesher", "Glued1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Gsr = {"_p_Gsr", "Gsr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GsrProcess = {"_p_GsrProcess", "GsrProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HaltonRsg = {"_p_HaltonRsg", "HaltonRsg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_BlackVolTermStructure_t = {"_p_HandleT_BlackVolTermStructure_t", "Handle< BlackVolTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_CalibratedModel_t = {"_p_HandleT_CalibratedModel_t", "Handle< CalibratedModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_CapFloorTermVolatilityStructure_t = {"_p_HandleT_CapFloorTermVolatilityStructure_t", "Handle< CapFloorTermVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_DefaultProbabilityTermStructure_t = {"_p_HandleT_DefaultProbabilityTermStructure_t", "Handle< DefaultProbabilityTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_DeltaVolQuote_t = {"_p_HandleT_DeltaVolQuote_t", "Handle< DeltaVolQuote > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_HestonModel_t = {"_p_HandleT_HestonModel_t", "Handle< HestonModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_LocalVolTermStructure_t = {"_p_HandleT_LocalVolTermStructure_t", "Handle< LocalVolTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_OptionletVolatilityStructure_t = {"_p_HandleT_OptionletVolatilityStructure_t", "Handle< OptionletVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_Quote_t = {"_p_HandleT_Quote_t", "Handle< Quote > *|std::vector< Handle< Quote > >::value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_ShortRateModel_t = {"_p_HandleT_ShortRateModel_t", "Handle< ShortRateModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_SwaptionVolatilityStructure_t = {"_p_HandleT_SwaptionVolatilityStructure_t", "Handle< SwaptionVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_YieldTermStructure_t = {"_p_HandleT_YieldTermStructure_t", "Handle< YieldTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_YoYInflationTermStructure_t = {"_p_HandleT_YoYInflationTermStructure_t", "Handle< YoYInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_YoYOptionletVolatilitySurface_t = {"_p_HandleT_YoYOptionletVolatilitySurface_t", "Handle< YoYOptionletVolatilitySurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HandleT_ZeroInflationTermStructure_t = {"_p_HandleT_ZeroInflationTermStructure_t", "Handle< ZeroInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HazardRate = {"_p_HazardRate", "HazardRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonBlackVolSurface = {"_p_HestonBlackVolSurface", "HestonBlackVolSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonModel = {"_p_HestonModel", "HestonModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonModelHelper = {"_p_HestonModelHelper", "HestonModelHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonProcess = {"_p_HestonProcess", "HestonProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonRNDCalculator = {"_p_HestonRNDCalculator", "HestonRNDCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonSLVFDMModel = {"_p_HestonSLVFDMModel", "HestonSLVFDMModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonSLVFokkerPlanckFdmParams = {"_p_HestonSLVFokkerPlanckFdmParams", "HestonSLVFokkerPlanckFdmParams *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonSLVMCModel = {"_p_HestonSLVMCModel", "HestonSLVMCModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HestonSLVProcess = {"_p_HestonSLVProcess", "HestonSLVProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HimalayaOption = {"_p_HimalayaOption", "HimalayaOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HullWhite = {"_p_HullWhite", "HullWhite *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HullWhiteForwardProcess = {"_p_HullWhiteForwardProcess", "HullWhiteForwardProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HullWhiteProcess = {"_p_HullWhiteProcess", "HullWhiteProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HundsdorferScheme = {"_p_HundsdorferScheme", "HundsdorferScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IMM = {"_p_IMM", "IMM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IborCoupon = {"_p_IborCoupon", "IborCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IborCouponPricer = {"_p_IborCouponPricer", "IborCouponPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IborIndex = {"_p_IborIndex", "IborIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ImplicitEulerScheme = {"_p_ImplicitEulerScheme", "ImplicitEulerScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ImpliedTermStructure = {"_p_ImpliedTermStructure", "ImpliedTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IncrementalStatistics = {"_p_IncrementalStatistics", "IncrementalStatistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Index = {"_p_Index", "Index *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IndexManager = {"_p_IndexManager", "IndexManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IndexedCashFlow = {"_p_IndexedCashFlow", "IndexedCashFlow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InflationCoupon = {"_p_InflationCoupon", "InflationCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InflationIndex = {"_p_InflationIndex", "InflationIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InflationTermStructure = {"_p_InflationTermStructure", "InflationTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Instrument = {"_p_Instrument", "Instrument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntegralCdsEngine = {"_p_IntegralCdsEngine", "IntegralCdsEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntegralEngine = {"_p_IntegralEngine", "IntegralEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Integration = {"_p_Integration", "Integration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterestRate = {"_p_InterestRate", "std::vector< InterestRate >::value_type *|InterestRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterestRateIndex = {"_p_InterestRateIndex", "InterestRateIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedDefaultDensityCurveT_Linear_t = {"_p_InterpolatedDefaultDensityCurveT_Linear_t", "InterpolatedDefaultDensityCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedDiscountCurveT_LogLinear_t = {"_p_InterpolatedDiscountCurveT_LogLinear_t", "InterpolatedDiscountCurve< LogLinear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t = {"_p_InterpolatedDiscountCurveT_MonotonicLogCubic_t", "InterpolatedDiscountCurve< MonotonicLogCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedDiscountCurveT_SplineCubic_t = {"_p_InterpolatedDiscountCurveT_SplineCubic_t", "InterpolatedDiscountCurve< SplineCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedForwardCurveT_BackwardFlat_t = {"_p_InterpolatedForwardCurveT_BackwardFlat_t", "InterpolatedForwardCurve< BackwardFlat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedHazardRateCurveT_BackwardFlat_t = {"_p_InterpolatedHazardRateCurveT_BackwardFlat_t", "InterpolatedHazardRateCurve< BackwardFlat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t = {"_p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t", "InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t = {"_p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t", "InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedSmileSectionT_Cubic_t = {"_p_InterpolatedSmileSectionT_Cubic_t", "InterpolatedSmileSection< Cubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedSmileSectionT_Linear_t = {"_p_InterpolatedSmileSectionT_Linear_t", "InterpolatedSmileSection< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedSmileSectionT_MonotonicCubic_t = {"_p_InterpolatedSmileSectionT_MonotonicCubic_t", "InterpolatedSmileSection< MonotonicCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedSmileSectionT_SplineCubic_t = {"_p_InterpolatedSmileSectionT_SplineCubic_t", "InterpolatedSmileSection< SplineCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedSurvivalProbabilityCurveT_Linear_t = {"_p_InterpolatedSurvivalProbabilityCurveT_Linear_t", "InterpolatedSurvivalProbabilityCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedYoYInflationCurveT_Linear_t = {"_p_InterpolatedYoYInflationCurveT_Linear_t", "InterpolatedYoYInflationCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedYoYOptionletStripperT_Linear_t = {"_p_InterpolatedYoYOptionletStripperT_Linear_t", "InterpolatedYoYOptionletStripper< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t = {"_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t", "InterpolatedYoYOptionletVolatilityCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroCurveT_Cubic_t = {"_p_InterpolatedZeroCurveT_Cubic_t", "InterpolatedZeroCurve< Cubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroCurveT_DefaultLogCubic_t = {"_p_InterpolatedZeroCurveT_DefaultLogCubic_t", "InterpolatedZeroCurve< DefaultLogCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroCurveT_Linear_t = {"_p_InterpolatedZeroCurveT_Linear_t", "InterpolatedZeroCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroCurveT_LogLinear_t = {"_p_InterpolatedZeroCurveT_LogLinear_t", "InterpolatedZeroCurve< LogLinear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroCurveT_MonotonicCubic_t = {"_p_InterpolatedZeroCurveT_MonotonicCubic_t", "InterpolatedZeroCurve< MonotonicCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroCurveT_SplineCubic_t = {"_p_InterpolatedZeroCurveT_SplineCubic_t", "InterpolatedZeroCurve< SplineCubic > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InterpolatedZeroInflationCurveT_Linear_t = {"_p_InterpolatedZeroInflationCurveT_Linear_t", "InterpolatedZeroInflationCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntervalPrice = {"_p_IntervalPrice", "std::vector< IntervalPrice >::value_type *|IntervalPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeNormal = {"_p_InverseCumulativeNormal", "InverseCumulativeNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativePoisson = {"_p_InverseCumulativePoisson", "InverseCumulativePoisson *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t = {"_p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t", "InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t", "InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t = {"_p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t", "InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t", "InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t = {"_p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t", "InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t", "InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t", "InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t", "InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t", "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t", "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t", "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t", "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t", "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t", "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t", "InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t = {"_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t", "InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseCumulativeStudent = {"_p_InverseCumulativeStudent", "InverseCumulativeStudent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InverseNonCentralCumulativeChiSquareDistribution = {"_p_InverseNonCentralCumulativeChiSquareDistribution", "InverseNonCentralCumulativeChiSquareDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IsdaCdsEngine = {"_p_IsdaCdsEngine", "IsdaCdsEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_JPYLibor = {"_p_JPYLibor", "JPYLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_JamshidianSwaptionEngine = {"_p_JamshidianSwaptionEngine", "JamshidianSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Jibar = {"_p_Jibar", "Jibar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_JpyLiborSwapIsdaFixAm = {"_p_JpyLiborSwapIsdaFixAm", "JpyLiborSwapIsdaFixAm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_JpyLiborSwapIsdaFixPm = {"_p_JpyLiborSwapIsdaFixPm", "JpyLiborSwapIsdaFixPm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_JuQuadraticApproximationEngine = {"_p_JuQuadraticApproximationEngine", "JuQuadraticApproximationEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t = {"_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t", "KInterpolatedYoYOptionletVolatilitySurface< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KahaleSmileSection = {"_p_KahaleSmileSection", "KahaleSmileSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KerkhofSeasonality = {"_p_KerkhofSeasonality", "KerkhofSeasonality *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KirkEngine = {"_p_KirkEngine", "KirkEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KirkSpreadOptionEngine = {"_p_KirkSpreadOptionEngine", "KirkSpreadOptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KlugeExtOUProcess = {"_p_KlugeExtOUProcess", "KlugeExtOUProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KnuthUniformRng = {"_p_KnuthUniformRng", "KnuthUniformRng *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Kruger = {"_p_Kruger", "Kruger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KrugerLog = {"_p_KrugerLog", "KrugerLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LecuyerUniformRng = {"_p_LecuyerUniformRng", "LecuyerUniformRng *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LevenbergMarquardt = {"_p_LevenbergMarquardt", "LevenbergMarquardt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Libor = {"_p_Libor", "Libor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Linear = {"_p_Linear", "Linear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinearTsrPricer = {"_p_LinearTsrPricer", "LinearTsrPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinearTsrPricer__Settings = {"_p_LinearTsrPricer__Settings", "LinearTsrPricer::Settings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LocalConstantVol = {"_p_LocalConstantVol", "LocalConstantVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LocalVolRNDCalculator = {"_p_LocalVolRNDCalculator", "LocalVolRNDCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LocalVolSurface = {"_p_LocalVolSurface", "LocalVolSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LocalVolTermStructure = {"_p_LocalVolTermStructure", "LocalVolTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LogLinear = {"_p_LogLinear", "LogLinear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LogNormalSimulatedAnnealing = {"_p_LogNormalSimulatedAnnealing", "LogNormalSimulatedAnnealing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LognormalCmsSpreadPricer = {"_p_LognormalCmsSpreadPricer", "LognormalCmsSpreadPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LsmBasisSystem = {"_p_LsmBasisSystem", "LsmBasisSystem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCAmericanBasketEngineT_LowDiscrepancy_t = {"_p_MCAmericanBasketEngineT_LowDiscrepancy_t", "MCAmericanBasketEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCAmericanBasketEngineT_PseudoRandom_t = {"_p_MCAmericanBasketEngineT_PseudoRandom_t", "MCAmericanBasketEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCAmericanEngineT_LowDiscrepancy_t = {"_p_MCAmericanEngineT_LowDiscrepancy_t", "MCAmericanEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCAmericanEngineT_PseudoRandom_t = {"_p_MCAmericanEngineT_PseudoRandom_t", "MCAmericanEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCBarrierEngineT_LowDiscrepancy_t = {"_p_MCBarrierEngineT_LowDiscrepancy_t", "MCBarrierEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCBarrierEngineT_PseudoRandom_t = {"_p_MCBarrierEngineT_PseudoRandom_t", "MCBarrierEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t = {"_p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t", "MCDiscreteArithmeticAPEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t = {"_p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t", "MCDiscreteArithmeticAPEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t = {"_p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t", "MCDiscreteArithmeticASEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t = {"_p_MCDiscreteArithmeticASEngineT_PseudoRandom_t", "MCDiscreteArithmeticASEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t = {"_p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t", "MCDiscreteGeometricAPEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t = {"_p_MCDiscreteGeometricAPEngineT_PseudoRandom_t", "MCDiscreteGeometricAPEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanBasketEngineT_LowDiscrepancy_t = {"_p_MCEuropeanBasketEngineT_LowDiscrepancy_t", "MCEuropeanBasketEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanBasketEngineT_PseudoRandom_t = {"_p_MCEuropeanBasketEngineT_PseudoRandom_t", "MCEuropeanBasketEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanEngineT_LowDiscrepancy_t = {"_p_MCEuropeanEngineT_LowDiscrepancy_t", "MCEuropeanEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanEngineT_PseudoRandom_t = {"_p_MCEuropeanEngineT_PseudoRandom_t", "MCEuropeanEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t = {"_p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t", "MCEuropeanGJRGARCHEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t = {"_p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t", "MCEuropeanGJRGARCHEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanHestonEngineT_LowDiscrepancy_t = {"_p_MCEuropeanHestonEngineT_LowDiscrepancy_t", "MCEuropeanHestonEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEuropeanHestonEngineT_PseudoRandom_t = {"_p_MCEuropeanHestonEngineT_PseudoRandom_t", "MCEuropeanHestonEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEverestEngineT_LowDiscrepancy_t = {"_p_MCEverestEngineT_LowDiscrepancy_t", "MCEverestEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCEverestEngineT_PseudoRandom_t = {"_p_MCEverestEngineT_PseudoRandom_t", "MCEverestEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCHimalayaEngineT_LowDiscrepancy_t = {"_p_MCHimalayaEngineT_LowDiscrepancy_t", "MCHimalayaEngine< LowDiscrepancy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MCHimalayaEngineT_PseudoRandom_t = {"_p_MCHimalayaEngineT_PseudoRandom_t", "MCHimalayaEngine< PseudoRandom > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MTBrownianGeneratorFactory = {"_p_MTBrownianGeneratorFactory", "MTBrownianGeneratorFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MakeOIS = {"_p_MakeOIS", "MakeOIS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MakeSchedule = {"_p_MakeSchedule", "MakeSchedule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MakeVanillaSwap = {"_p_MakeVanillaSwap", "MakeVanillaSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MarkovFunctional = {"_p_MarkovFunctional", "MarkovFunctional *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MarkovFunctional__ModelSettings = {"_p_MarkovFunctional__ModelSettings", "MarkovFunctional::ModelSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Matrix = {"_p_Matrix", "Matrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MatrixMultiplicationProxy = {"_p_MatrixMultiplicationProxy", "MatrixMultiplicationProxy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MatrixRow = {"_p_MatrixRow", "MatrixRow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MaxBasketPayoff = {"_p_MaxBasketPayoff", "MaxBasketPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MersenneTwisterUniformRng = {"_p_MersenneTwisterUniformRng", "MersenneTwisterUniformRng *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Merton76Process = {"_p_Merton76Process", "Merton76Process *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MethodOfLinesScheme = {"_p_MethodOfLinesScheme", "MethodOfLinesScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MidPointCdsEngine = {"_p_MidPointCdsEngine", "MidPointCdsEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MinBasketPayoff = {"_p_MinBasketPayoff", "MinBasketPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MirrorGaussianSimulatedAnnealing = {"_p_MirrorGaussianSimulatedAnnealing", "MirrorGaussianSimulatedAnnealing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ModifiedCraigSneydScheme = {"_p_ModifiedCraigSneydScheme", "ModifiedCraigSneydScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Money = {"_p_Money", "Money *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MonotonicCubic = {"_p_MonotonicCubic", "MonotonicCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MonotonicLogCubic = {"_p_MonotonicLogCubic", "MonotonicLogCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MoroInverseCumulativeNormal = {"_p_MoroInverseCumulativeNormal", "MoroInverseCumulativeNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mosprime = {"_p_Mosprime", "Mosprime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MultiAssetOption = {"_p_MultiAssetOption", "MultiAssetOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MultiPath = {"_p_MultiPath", "MultiPath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MultiplicativePriceSeasonality = {"_p_MultiplicativePriceSeasonality", "MultiplicativePriceSeasonality *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NZDLibor = {"_p_NZDLibor", "NZDLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NelsonSiegelFitting = {"_p_NelsonSiegelFitting", "NelsonSiegelFitting *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NeumannBC = {"_p_NeumannBC", "NeumannBC *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Newton = {"_p_Newton", "Newton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NewtonSafe = {"_p_NewtonSafe", "NewtonSafe *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NinePointLinearOp = {"_p_NinePointLinearOp", "NinePointLinearOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NoArbSabrInterpolatedSmileSection = {"_p_NoArbSabrInterpolatedSmileSection", "NoArbSabrInterpolatedSmileSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NoArbSabrSmileSection = {"_p_NoArbSabrSmileSection", "NoArbSabrSmileSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NoConstraint = {"_p_NoConstraint", "NoConstraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NoExceptLocalVolSurface = {"_p_NoExceptLocalVolSurface", "NoExceptLocalVolSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NonCentralCumulativeChiSquareDistribution = {"_p_NonCentralCumulativeChiSquareDistribution", "NonCentralCumulativeChiSquareDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NonhomogeneousBoundaryConstraint = {"_p_NonhomogeneousBoundaryConstraint", "NonhomogeneousBoundaryConstraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NonstandardSwap = {"_p_NonstandardSwap", "NonstandardSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NonstandardSwaption = {"_p_NonstandardSwaption", "NonstandardSwaption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NormalDistribution = {"_p_NormalDistribution", "NormalDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NthOrderDerivativeOp = {"_p_NthOrderDerivativeOp", "NthOrderDerivativeOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NullParameter = {"_p_NullParameter", "NullParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NumericHaganPricer = {"_p_NumericHaganPricer", "NumericHaganPricer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Nzocr = {"_p_Nzocr", "Nzocr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OISRateHelper = {"_p_OISRateHelper", "OISRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Observable = {"_p_Observable", "Observable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OneAssetOption = {"_p_OneAssetOption", "OneAssetOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OneFactorAffineModel = {"_p_OneFactorAffineModel", "OneFactorAffineModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OptimizationMethod = {"_p_OptimizationMethod", "OptimizationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Optimizer = {"_p_Optimizer", "Optimizer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Option = {"_p_Option", "Option *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OptionletStripper1 = {"_p_OptionletStripper1", "OptionletStripper1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OptionletVolatilityStructure = {"_p_OptionletVolatilityStructure", "OptionletVolatilityStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OrnsteinUhlenbeckProcess = {"_p_OrnsteinUhlenbeckProcess", "OrnsteinUhlenbeckProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OvernightIndex = {"_p_OvernightIndex", "OvernightIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OvernightIndexFuture = {"_p_OvernightIndexFuture", "OvernightIndexFuture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OvernightIndexFutureRateHelper = {"_p_OvernightIndexFutureRateHelper", "OvernightIndexFutureRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OvernightIndexedCoupon = {"_p_OvernightIndexedCoupon", "OvernightIndexedCoupon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OvernightIndexedSwap = {"_p_OvernightIndexedSwap", "OvernightIndexedSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OvernightIndexedSwapIndex = {"_p_OvernightIndexedSwapIndex", "OvernightIndexedSwapIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Parameter = {"_p_Parameter", "Parameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParkinsonSigma = {"_p_ParkinsonSigma", "ParkinsonSigma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Path = {"_p_Path", "Path *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t = {"_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t", "PathGenerator< GaussianLowDiscrepancySequenceGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PathGeneratorT_GaussianRandomSequenceGenerator_t = {"_p_PathGeneratorT_GaussianRandomSequenceGenerator_t", "PathGenerator< GaussianRandomSequenceGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t = {"_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t", "PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Payoff = {"_p_Payoff", "Payoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PercentageStrikePayoff = {"_p_PercentageStrikePayoff", "PercentageStrikePayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Period = {"_p_Period", "std::vector< Period >::value_type *|Period *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PeriodParser = {"_p_PeriodParser", "PeriodParser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseConstantParameter = {"_p_PiecewiseConstantParameter", "PiecewiseConstantParameter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseConvexMonotoneZero = {"_p_PiecewiseConvexMonotoneZero", "PiecewiseConvexMonotoneZero *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseCubicZero = {"_p_PiecewiseCubicZero", "PiecewiseCubicZero *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseFlatForward = {"_p_PiecewiseFlatForward", "PiecewiseFlatForward *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseFlatHazardRate = {"_p_PiecewiseFlatHazardRate", "PiecewiseFlatHazardRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseKrugerLogDiscount = {"_p_PiecewiseKrugerLogDiscount", "PiecewiseKrugerLogDiscount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseKrugerZero = {"_p_PiecewiseKrugerZero", "PiecewiseKrugerZero *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseLinearForward = {"_p_PiecewiseLinearForward", "PiecewiseLinearForward *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseLinearZero = {"_p_PiecewiseLinearZero", "PiecewiseLinearZero *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseLogCubicDiscount = {"_p_PiecewiseLogCubicDiscount", "PiecewiseLogCubicDiscount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseLogLinearDiscount = {"_p_PiecewiseLogLinearDiscount", "PiecewiseLogLinearDiscount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseSplineCubicDiscount = {"_p_PiecewiseSplineCubicDiscount", "PiecewiseSplineCubicDiscount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseTimeDependentHestonModel = {"_p_PiecewiseTimeDependentHestonModel", "PiecewiseTimeDependentHestonModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseYoYInflationCurveT_Linear_t = {"_p_PiecewiseYoYInflationCurveT_Linear_t", "PiecewiseYoYInflationCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PiecewiseZeroInflationCurveT_Linear_t = {"_p_PiecewiseZeroInflationCurveT_Linear_t", "PiecewiseZeroInflationCurve< Linear > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pillar = {"_p_Pillar", "Pillar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PlainVanillaPayoff = {"_p_PlainVanillaPayoff", "PlainVanillaPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PoissonDistribution = {"_p_PoissonDistribution", "PoissonDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Position = {"_p_Position", "Position *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PositiveConstraint = {"_p_PositiveConstraint", "PositiveConstraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Predefined1dMesher = {"_p_Predefined1dMesher", "Predefined1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pribor = {"_p_Pribor", "Pribor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PricingEngine = {"_p_PricingEngine", "PricingEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ProbabilityBoltzmannDownhill = {"_p_ProbabilityBoltzmannDownhill", "ProbabilityBoltzmannDownhill *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Protection = {"_p_Protection", "Protection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PyObserver = {"_p_PyObserver", "PyObserver *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ARSCurrency = {"_p_QuantLib__ARSCurrency", "QuantLib::ARSCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ATSCurrency = {"_p_QuantLib__ATSCurrency", "QuantLib::ATSCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__AUDCurrency = {"_p_QuantLib__AUDCurrency", "QuantLib::AUDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Actual360 = {"_p_QuantLib__Actual360", "QuantLib::Actual360 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Actual364 = {"_p_QuantLib__Actual364", "QuantLib::Actual364 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Actual365Fixed = {"_p_QuantLib__Actual365Fixed", "QuantLib::Actual365Fixed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ActualActual = {"_p_QuantLib__ActualActual", "QuantLib::ActualActual *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Argentina = {"_p_QuantLib__Argentina", "QuantLib::Argentina *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Australia = {"_p_QuantLib__Australia", "QuantLib::Australia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__BDTCurrency = {"_p_QuantLib__BDTCurrency", "QuantLib::BDTCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__BEFCurrency = {"_p_QuantLib__BEFCurrency", "QuantLib::BEFCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__BGLCurrency = {"_p_QuantLib__BGLCurrency", "QuantLib::BGLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__BRLCurrency = {"_p_QuantLib__BRLCurrency", "QuantLib::BRLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__BYRCurrency = {"_p_QuantLib__BYRCurrency", "QuantLib::BYRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__BespokeCalendar = {"_p_QuantLib__BespokeCalendar", "QuantLib::BespokeCalendar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Brazil = {"_p_QuantLib__Brazil", "QuantLib::Brazil *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Business252 = {"_p_QuantLib__Business252", "QuantLib::Business252 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CADCurrency = {"_p_QuantLib__CADCurrency", "QuantLib::CADCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CHFCurrency = {"_p_QuantLib__CHFCurrency", "QuantLib::CHFCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CLPCurrency = {"_p_QuantLib__CLPCurrency", "QuantLib::CLPCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CNYCurrency = {"_p_QuantLib__CNYCurrency", "QuantLib::CNYCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__COPCurrency = {"_p_QuantLib__COPCurrency", "QuantLib::COPCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CYPCurrency = {"_p_QuantLib__CYPCurrency", "QuantLib::CYPCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CZKCurrency = {"_p_QuantLib__CZKCurrency", "QuantLib::CZKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Canada = {"_p_QuantLib__Canada", "QuantLib::Canada *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__China = {"_p_QuantLib__China", "QuantLib::China *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__CzechRepublic = {"_p_QuantLib__CzechRepublic", "QuantLib::CzechRepublic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__DEMCurrency = {"_p_QuantLib__DEMCurrency", "QuantLib::DEMCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__DKKCurrency = {"_p_QuantLib__DKKCurrency", "QuantLib::DKKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Denmark = {"_p_QuantLib__Denmark", "QuantLib::Denmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__EEKCurrency = {"_p_QuantLib__EEKCurrency", "QuantLib::EEKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ESPCurrency = {"_p_QuantLib__ESPCurrency", "QuantLib::ESPCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__EURCurrency = {"_p_QuantLib__EURCurrency", "QuantLib::EURCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__FIMCurrency = {"_p_QuantLib__FIMCurrency", "QuantLib::FIMCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__FRFCurrency = {"_p_QuantLib__FRFCurrency", "QuantLib::FRFCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Finland = {"_p_QuantLib__Finland", "QuantLib::Finland *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__France = {"_p_QuantLib__France", "QuantLib::France *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__GBPCurrency = {"_p_QuantLib__GBPCurrency", "QuantLib::GBPCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__GRDCurrency = {"_p_QuantLib__GRDCurrency", "QuantLib::GRDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Germany = {"_p_QuantLib__Germany", "QuantLib::Germany *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__HKDCurrency = {"_p_QuantLib__HKDCurrency", "QuantLib::HKDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__HUFCurrency = {"_p_QuantLib__HUFCurrency", "QuantLib::HUFCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__HongKong = {"_p_QuantLib__HongKong", "QuantLib::HongKong *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Hungary = {"_p_QuantLib__Hungary", "QuantLib::Hungary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__IDRCurrency = {"_p_QuantLib__IDRCurrency", "QuantLib::IDRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__IEPCurrency = {"_p_QuantLib__IEPCurrency", "QuantLib::IEPCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ILSCurrency = {"_p_QuantLib__ILSCurrency", "QuantLib::ILSCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__INRCurrency = {"_p_QuantLib__INRCurrency", "QuantLib::INRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__IQDCurrency = {"_p_QuantLib__IQDCurrency", "QuantLib::IQDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__IRRCurrency = {"_p_QuantLib__IRRCurrency", "QuantLib::IRRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ISKCurrency = {"_p_QuantLib__ISKCurrency", "QuantLib::ISKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ITLCurrency = {"_p_QuantLib__ITLCurrency", "QuantLib::ITLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Iceland = {"_p_QuantLib__Iceland", "QuantLib::Iceland *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__India = {"_p_QuantLib__India", "QuantLib::India *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Indonesia = {"_p_QuantLib__Indonesia", "QuantLib::Indonesia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Israel = {"_p_QuantLib__Israel", "QuantLib::Israel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Italy = {"_p_QuantLib__Italy", "QuantLib::Italy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__JPYCurrency = {"_p_QuantLib__JPYCurrency", "QuantLib::JPYCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Japan = {"_p_QuantLib__Japan", "QuantLib::Japan *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__JointCalendar = {"_p_QuantLib__JointCalendar", "QuantLib::JointCalendar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__KRWCurrency = {"_p_QuantLib__KRWCurrency", "QuantLib::KRWCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__KWDCurrency = {"_p_QuantLib__KWDCurrency", "QuantLib::KWDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__LTLCurrency = {"_p_QuantLib__LTLCurrency", "QuantLib::LTLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__LUFCurrency = {"_p_QuantLib__LUFCurrency", "QuantLib::LUFCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__LVLCurrency = {"_p_QuantLib__LVLCurrency", "QuantLib::LVLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__MTLCurrency = {"_p_QuantLib__MTLCurrency", "QuantLib::MTLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__MXNCurrency = {"_p_QuantLib__MXNCurrency", "QuantLib::MXNCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__MYRCurrency = {"_p_QuantLib__MYRCurrency", "QuantLib::MYRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Mexico = {"_p_QuantLib__Mexico", "QuantLib::Mexico *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__NLGCurrency = {"_p_QuantLib__NLGCurrency", "QuantLib::NLGCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__NOKCurrency = {"_p_QuantLib__NOKCurrency", "QuantLib::NOKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__NPRCurrency = {"_p_QuantLib__NPRCurrency", "QuantLib::NPRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__NZDCurrency = {"_p_QuantLib__NZDCurrency", "QuantLib::NZDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__NewZealand = {"_p_QuantLib__NewZealand", "QuantLib::NewZealand *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Norway = {"_p_QuantLib__Norway", "QuantLib::Norway *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__NullCalendar = {"_p_QuantLib__NullCalendar", "QuantLib::NullCalendar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__OneDayCounter = {"_p_QuantLib__OneDayCounter", "QuantLib::OneDayCounter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__PEHCurrency = {"_p_QuantLib__PEHCurrency", "QuantLib::PEHCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__PEICurrency = {"_p_QuantLib__PEICurrency", "QuantLib::PEICurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__PENCurrency = {"_p_QuantLib__PENCurrency", "QuantLib::PENCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__PKRCurrency = {"_p_QuantLib__PKRCurrency", "QuantLib::PKRCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__PLNCurrency = {"_p_QuantLib__PLNCurrency", "QuantLib::PLNCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__PTECurrency = {"_p_QuantLib__PTECurrency", "QuantLib::PTECurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Poland = {"_p_QuantLib__Poland", "QuantLib::Poland *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ROLCurrency = {"_p_QuantLib__ROLCurrency", "QuantLib::ROLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__RONCurrency = {"_p_QuantLib__RONCurrency", "QuantLib::RONCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__RUBCurrency = {"_p_QuantLib__RUBCurrency", "QuantLib::RUBCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Romania = {"_p_QuantLib__Romania", "QuantLib::Romania *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Russia = {"_p_QuantLib__Russia", "QuantLib::Russia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SARCurrency = {"_p_QuantLib__SARCurrency", "QuantLib::SARCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SEKCurrency = {"_p_QuantLib__SEKCurrency", "QuantLib::SEKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SGDCurrency = {"_p_QuantLib__SGDCurrency", "QuantLib::SGDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SITCurrency = {"_p_QuantLib__SITCurrency", "QuantLib::SITCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SKKCurrency = {"_p_QuantLib__SKKCurrency", "QuantLib::SKKCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SaudiArabia = {"_p_QuantLib__SaudiArabia", "QuantLib::SaudiArabia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SimpleDayCounter = {"_p_QuantLib__SimpleDayCounter", "QuantLib::SimpleDayCounter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Singapore = {"_p_QuantLib__Singapore", "QuantLib::Singapore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Slovakia = {"_p_QuantLib__Slovakia", "QuantLib::Slovakia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SouthAfrica = {"_p_QuantLib__SouthAfrica", "QuantLib::SouthAfrica *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__SouthKorea = {"_p_QuantLib__SouthKorea", "QuantLib::SouthKorea *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Sweden = {"_p_QuantLib__Sweden", "QuantLib::Sweden *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Switzerland = {"_p_QuantLib__Switzerland", "QuantLib::Switzerland *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__TARGET = {"_p_QuantLib__TARGET", "QuantLib::TARGET *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__THBCurrency = {"_p_QuantLib__THBCurrency", "QuantLib::THBCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__TRLCurrency = {"_p_QuantLib__TRLCurrency", "QuantLib::TRLCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__TRYCurrency = {"_p_QuantLib__TRYCurrency", "QuantLib::TRYCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__TTDCurrency = {"_p_QuantLib__TTDCurrency", "QuantLib::TTDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__TWDCurrency = {"_p_QuantLib__TWDCurrency", "QuantLib::TWDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Taiwan = {"_p_QuantLib__Taiwan", "QuantLib::Taiwan *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Thailand = {"_p_QuantLib__Thailand", "QuantLib::Thailand *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Thirty360 = {"_p_QuantLib__Thirty360", "QuantLib::Thirty360 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Thirty365 = {"_p_QuantLib__Thirty365", "QuantLib::Thirty365 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Turkey = {"_p_QuantLib__Turkey", "QuantLib::Turkey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__USDCurrency = {"_p_QuantLib__USDCurrency", "QuantLib::USDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__Ukraine = {"_p_QuantLib__Ukraine", "QuantLib::Ukraine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__UnitedKingdom = {"_p_QuantLib__UnitedKingdom", "QuantLib::UnitedKingdom *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__UnitedStates = {"_p_QuantLib__UnitedStates", "QuantLib::UnitedStates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__VEBCurrency = {"_p_QuantLib__VEBCurrency", "QuantLib::VEBCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__VNDCurrency = {"_p_QuantLib__VNDCurrency", "QuantLib::VNDCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__WeekendsOnly = {"_p_QuantLib__WeekendsOnly", "QuantLib::WeekendsOnly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantLib__ZARCurrency = {"_p_QuantLib__ZARCurrency", "QuantLib::ZARCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantoDoubleBarrierOption = {"_p_QuantoDoubleBarrierOption", "QuantoDoubleBarrierOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantoEuropeanEngine = {"_p_QuantoEuropeanEngine", "QuantoEuropeanEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantoForwardEuropeanEngine = {"_p_QuantoForwardEuropeanEngine", "QuantoForwardEuropeanEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantoForwardVanillaOption = {"_p_QuantoForwardVanillaOption", "QuantoForwardVanillaOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuantoVanillaOption = {"_p_QuantoVanillaOption", "QuantoVanillaOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Quote = {"_p_Quote", "Quote *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RandomSequenceGeneratorT_KnuthUniformRng_t = {"_p_RandomSequenceGeneratorT_KnuthUniformRng_t", "RandomSequenceGenerator< KnuthUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RandomSequenceGeneratorT_LecuyerUniformRng_t = {"_p_RandomSequenceGeneratorT_LecuyerUniformRng_t", "RandomSequenceGenerator< LecuyerUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t = {"_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t", "RandomSequenceGenerator< MersenneTwisterUniformRng > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RateHelper = {"_p_RateHelper", "RateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RealTimeSeries = {"_p_RealTimeSeries", "RealTimeSeries *|VolatilityTimeSeries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ReannealingTrivial = {"_p_ReannealingTrivial", "ReannealingTrivial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RebatedExercise = {"_p_RebatedExercise", "RebatedExercise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Redemption = {"_p_Redemption", "Redemption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Region = {"_p_Region", "Region *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_BlackVolTermStructure_t = {"_p_RelinkableHandleT_BlackVolTermStructure_t", "RelinkableHandle< BlackVolTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_CalibratedModel_t = {"_p_RelinkableHandleT_CalibratedModel_t", "RelinkableHandle< CalibratedModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_CapFloorTermVolatilityStructure_t = {"_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t", "RelinkableHandle< CapFloorTermVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_DefaultProbabilityTermStructure_t = {"_p_RelinkableHandleT_DefaultProbabilityTermStructure_t", "RelinkableHandle< DefaultProbabilityTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_DeltaVolQuote_t = {"_p_RelinkableHandleT_DeltaVolQuote_t", "RelinkableHandle< DeltaVolQuote > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_LocalVolTermStructure_t = {"_p_RelinkableHandleT_LocalVolTermStructure_t", "RelinkableHandle< LocalVolTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_OptionletVolatilityStructure_t = {"_p_RelinkableHandleT_OptionletVolatilityStructure_t", "RelinkableHandle< OptionletVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_Quote_t = {"_p_RelinkableHandleT_Quote_t", "RelinkableHandle< Quote > *|std::vector< RelinkableHandle< Quote > >::value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_ShortRateModel_t = {"_p_RelinkableHandleT_ShortRateModel_t", "RelinkableHandle< ShortRateModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_SwaptionVolatilityStructure_t = {"_p_RelinkableHandleT_SwaptionVolatilityStructure_t", "RelinkableHandle< SwaptionVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_YieldTermStructure_t = {"_p_RelinkableHandleT_YieldTermStructure_t", "RelinkableHandle< YieldTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_YoYInflationTermStructure_t = {"_p_RelinkableHandleT_YoYInflationTermStructure_t", "RelinkableHandle< YoYInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_YoYOptionletVolatilitySurface_t = {"_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t", "RelinkableHandle< YoYOptionletVolatilitySurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RelinkableHandleT_ZeroInflationTermStructure_t = {"_p_RelinkableHandleT_ZeroInflationTermStructure_t", "RelinkableHandle< ZeroInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RichardsonExtrapolation = {"_p_RichardsonExtrapolation", "RichardsonExtrapolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ridder = {"_p_Ridder", "Ridder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RiskNeutralDensityCalculator = {"_p_RiskNeutralDensityCalculator", "RiskNeutralDensityCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RiskStatistics = {"_p_RiskStatistics", "RiskStatistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Robor = {"_p_Robor", "Robor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Rounding = {"_p_Rounding", "Rounding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SEKLibor = {"_p_SEKLibor", "SEKLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SVD = {"_p_SVD", "SVD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SabrSmileSection = {"_p_SabrSmileSection", "SabrSmileSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeBackwardFlatInterpolation = {"_p_SafeBackwardFlatInterpolation", "SafeBackwardFlatInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeBicubicSpline = {"_p_SafeBicubicSpline", "SafeBicubicSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeBilinearInterpolation = {"_p_SafeBilinearInterpolation", "SafeBilinearInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeConvexMonotoneInterpolation = {"_p_SafeConvexMonotoneInterpolation", "SafeConvexMonotoneInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeCubicNaturalSpline = {"_p_SafeCubicNaturalSpline", "SafeCubicNaturalSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeForwardFlatInterpolation = {"_p_SafeForwardFlatInterpolation", "SafeForwardFlatInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeFritschButlandCubic = {"_p_SafeFritschButlandCubic", "SafeFritschButlandCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeFritschButlandLogCubic = {"_p_SafeFritschButlandLogCubic", "SafeFritschButlandLogCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeKrugerCubic = {"_p_SafeKrugerCubic", "SafeKrugerCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeKrugerLogCubic = {"_p_SafeKrugerLogCubic", "SafeKrugerLogCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeLinearInterpolation = {"_p_SafeLinearInterpolation", "SafeLinearInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeLogCubicNaturalSpline = {"_p_SafeLogCubicNaturalSpline", "SafeLogCubicNaturalSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeLogLinearInterpolation = {"_p_SafeLogLinearInterpolation", "SafeLogLinearInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeLogParabolic = {"_p_SafeLogParabolic", "SafeLogParabolic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeMonotonicCubicNaturalSpline = {"_p_SafeMonotonicCubicNaturalSpline", "SafeMonotonicCubicNaturalSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeMonotonicLogCubicNaturalSpline = {"_p_SafeMonotonicLogCubicNaturalSpline", "SafeMonotonicLogCubicNaturalSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeMonotonicLogParabolic = {"_p_SafeMonotonicLogParabolic", "SafeMonotonicLogParabolic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeMonotonicParabolic = {"_p_SafeMonotonicParabolic", "SafeMonotonicParabolic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeParabolic = {"_p_SafeParabolic", "SafeParabolic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SafeSABRInterpolation = {"_p_SafeSABRInterpolation", "SafeSABRInterpolation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SalvagingAlgorithm = {"_p_SalvagingAlgorithm", "SalvagingAlgorithm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SampleT_Array_t = {"_p_SampleT_Array_t", "Sample< Array > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SampleT_MultiPath_t = {"_p_SampleT_MultiPath_t", "Sample< MultiPath > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SampleT_Path_t = {"_p_SampleT_Path_t", "PathGenerator< GaussianRandomSequenceGenerator >::sample_type *|PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *|Sample< Path > *|PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SampleT_double_t = {"_p_SampleT_double_t", "Sample< Real > *|Sample< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t", "Sample< std::vector< double > > *|Sample< std::vector< Real > > *|Sample< std::vector< Real,std::allocator< Real > > > *|Sample< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SampledCurve = {"_p_SampledCurve", "SampledCurve *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SamplerGaussian = {"_p_SamplerGaussian", "SamplerGaussian *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SamplerLogNormal = {"_p_SamplerLogNormal", "SamplerLogNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SamplerMirrorGaussian = {"_p_SamplerMirrorGaussian", "SamplerMirrorGaussian *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Schedule = {"_p_Schedule", "Schedule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Seasonality = {"_p_Seasonality", "Seasonality *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Secant = {"_p_Secant", "Secant *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SecondDerivativeOp = {"_p_SecondDerivativeOp", "SecondDerivativeOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SecondOrderMixedDerivativeOp = {"_p_SecondOrderMixedDerivativeOp", "SecondOrderMixedDerivativeOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SegmentIntegral = {"_p_SegmentIntegral", "SegmentIntegral *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Settings = {"_p_Settings", "Settings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Settlement = {"_p_Settlement", "Settlement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Shibor = {"_p_Shibor", "Shibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShortRateModel = {"_p_ShortRateModel", "ShortRateModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Side = {"_p_Side", "Side *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimpleCashFlow = {"_p_SimpleCashFlow", "SimpleCashFlow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimplePolynomialFitting = {"_p_SimplePolynomialFitting", "SimplePolynomialFitting *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimpleQuote = {"_p_SimpleQuote", "SimpleQuote *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Simplex = {"_p_Simplex", "Simplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimpsonIntegral = {"_p_SimpsonIntegral", "SimpsonIntegral *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SmileSection = {"_p_SmileSection", "SmileSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SobolBrownianBridgeRsg = {"_p_SobolBrownianBridgeRsg", "SobolBrownianBridgeRsg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SobolBrownianGenerator = {"_p_SobolBrownianGenerator", "SobolBrownianGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SobolBrownianGeneratorFactory = {"_p_SobolBrownianGeneratorFactory", "SobolBrownianGeneratorFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SobolRsg = {"_p_SobolRsg", "SobolRsg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Sofr = {"_p_Sofr", "Sofr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SofrFutureRateHelper = {"_p_SofrFutureRateHelper", "SofrFutureRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoftCallability = {"_p_SoftCallability", "SoftCallability *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Sonia = {"_p_Sonia", "Sonia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SplineCubic = {"_p_SplineCubic", "SplineCubic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpreadBasketPayoff = {"_p_SpreadBasketPayoff", "SpreadBasketPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpreadCdsHelper = {"_p_SpreadCdsHelper", "SpreadCdsHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpreadOption = {"_p_SpreadOption", "SpreadOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SquareRootProcessRNDCalculator = {"_p_SquareRootProcessRNDCalculator", "SquareRootProcessRNDCalculator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Statistics = {"_p_Statistics", "Statistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SteepestDescent = {"_p_SteepestDescent", "SteepestDescent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StepConditionT_Array_t = {"_p_StepConditionT_Array_t", "StepCondition< Array > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StochasticProcess = {"_p_StochasticProcess", "StochasticProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StochasticProcess1D = {"_p_StochasticProcess1D", "StochasticProcess1D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StochasticProcessArray = {"_p_StochasticProcessArray", "StochasticProcessArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Stock = {"_p_Stock", "Stock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StrikedTypePayoff = {"_p_StrikedTypePayoff", "StrikedTypePayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StrippedOptionletAdapter = {"_p_StrippedOptionletAdapter", "StrippedOptionletAdapter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StrippedOptionletBase = {"_p_StrippedOptionletBase", "StrippedOptionletBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StudentDistribution = {"_p_StudentDistribution", "StudentDistribution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StulzEngine = {"_p_StulzEngine", "StulzEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SuperSharePayoff = {"_p_SuperSharePayoff", "SuperSharePayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SvenssonFitting = {"_p_SvenssonFitting", "SvenssonFitting *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Swap = {"_p_Swap", "Swap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwapIndex = {"_p_SwapIndex", "SwapIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwapRateHelper = {"_p_SwapRateHelper", "SwapRateHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwapSpreadIndex = {"_p_SwapSpreadIndex", "SwapSpreadIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Swaption = {"_p_Swaption", "Swaption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionHelper = {"_p_SwaptionHelper", "SwaptionHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionVolCube1 = {"_p_SwaptionVolCube1", "SwaptionVolCube1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionVolCube2 = {"_p_SwaptionVolCube2", "SwaptionVolCube2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionVolatilityCube = {"_p_SwaptionVolatilityCube", "SwaptionVolatilityCube *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionVolatilityDiscrete = {"_p_SwaptionVolatilityDiscrete", "SwaptionVolatilityDiscrete *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionVolatilityMatrix = {"_p_SwaptionVolatilityMatrix", "SwaptionVolatilityMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwaptionVolatilityStructure = {"_p_SwaptionVolatilityStructure", "SwaptionVolatilityStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SwingExercise = {"_p_SwingExercise", "SwingExercise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_THBFIX = {"_p_THBFIX", "THBFIX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TRLibor = {"_p_TRLibor", "TRLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TemperatureExponential = {"_p_TemperatureExponential", "TemperatureExponential *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TermStructure = {"_p_TermStructure", "TermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TermStructureConsistentModel = {"_p_TermStructureConsistentModel", "TermStructureConsistentModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Tibor = {"_p_Tibor", "Tibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeBasket = {"_p_TimeBasket", "TimeBasket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeGrid = {"_p_TimeGrid", "TimeGrid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t = {"_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t", "TimeSeries< IntervalPrice > *|TimeSeries< IntervalPrice,std::map< Date,IntervalPrice,std::less< Date >,std::allocator< std::pair< Date const,IntervalPrice > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t = {"_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t", "TimeSeries< double,std::map< Date,double,std::less< Date >,std::allocator< std::pair< Date const,double > > > > *|TimeSeries< Volatility > *|TimeSeries< Real > *|TimeSeries< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TrapezoidIntegralT_Default_t = {"_p_TrapezoidIntegralT_Default_t", "TrapezoidIntegral< Default > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TrapezoidIntegralT_MidPoint_t = {"_p_TrapezoidIntegralT_MidPoint_t", "TrapezoidIntegral< MidPoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TreeCallableFixedRateBondEngine = {"_p_TreeCallableFixedRateBondEngine", "TreeCallableFixedRateBondEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TreeCapFloorEngine = {"_p_TreeCapFloorEngine", "TreeCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TreeSwaptionEngine = {"_p_TreeSwaptionEngine", "TreeSwaptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TridiagonalOperator = {"_p_TridiagonalOperator", "TridiagonalOperator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TripleBandLinearOp = {"_p_TripleBandLinearOp", "TripleBandLinearOp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TypePayoff = {"_p_TypePayoff", "TypePayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UKRPI = {"_p_UKRPI", "UKRPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_USCPI = {"_p_USCPI", "USCPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_USDLibor = {"_p_USDLibor", "USDLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_USDLiborON = {"_p_USDLiborON", "USDLiborON *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Uniform1dMesher = {"_p_Uniform1dMesher", "Uniform1dMesher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UniformLowDiscrepancySequenceGenerator = {"_p_UniformLowDiscrepancySequenceGenerator", "UniformLowDiscrepancySequenceGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UniformRandomGenerator = {"_p_UniformRandomGenerator", "UniformRandomGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UniformRandomSequenceGenerator = {"_p_UniformRandomSequenceGenerator", "UniformRandomSequenceGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UpRounding = {"_p_UpRounding", "UpRounding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UpfrontCdsHelper = {"_p_UpfrontCdsHelper", "UpfrontCdsHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UsdLiborSwapIsdaFixAm = {"_p_UsdLiborSwapIsdaFixAm", "UsdLiborSwapIsdaFixAm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UsdLiborSwapIsdaFixPm = {"_p_UsdLiborSwapIsdaFixPm", "UsdLiborSwapIsdaFixPm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VanillaForwardPayoff = {"_p_VanillaForwardPayoff", "VanillaForwardPayoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VanillaOption = {"_p_VanillaOption", "VanillaOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VanillaSwap = {"_p_VanillaSwap", "VanillaSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VanillaSwingOption = {"_p_VanillaSwingOption", "VanillaSwingOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VannaVolgaBarrierEngine = {"_p_VannaVolgaBarrierEngine", "VannaVolgaBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t = {"_p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t", "VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t = {"_p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t", "VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VarianceGammaEngine = {"_p_VarianceGammaEngine", "VarianceGammaEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VarianceGammaProcess = {"_p_VarianceGammaProcess", "VarianceGammaProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Vasicek = {"_p_Vasicek", "Vasicek *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VolatilityTermStructure = {"_p_VolatilityTermStructure", "VolatilityTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Wibor = {"_p_Wibor", "Wibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_WulinYongDoubleBarrierEngine = {"_p_WulinYongDoubleBarrierEngine", "WulinYongDoubleBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYEUHICP = {"_p_YYEUHICP", "YYEUHICP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYEUHICPXT = {"_p_YYEUHICPXT", "YYEUHICPXT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYEUHICPr = {"_p_YYEUHICPr", "YYEUHICPr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYFRHICP = {"_p_YYFRHICP", "YYFRHICP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYFRHICPr = {"_p_YYFRHICPr", "YYFRHICPr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYUKRPI = {"_p_YYUKRPI", "YYUKRPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYUKRPIr = {"_p_YYUKRPIr", "YYUKRPIr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYUSCPI = {"_p_YYUSCPI", "YYUSCPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYUSCPIr = {"_p_YYUSCPIr", "YYUSCPIr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYZACPI = {"_p_YYZACPI", "YYZACPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YYZACPIr = {"_p_YYZACPIr", "YYZACPIr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YearOnYearInflationSwap = {"_p_YearOnYearInflationSwap", "YearOnYearInflationSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YearOnYearInflationSwapHelper = {"_p_YearOnYearInflationSwapHelper", "YearOnYearInflationSwapHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YieldTermStructure = {"_p_YieldTermStructure", "YieldTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYCapFloorTermPriceSurface = {"_p_YoYCapFloorTermPriceSurface", "YoYCapFloorTermPriceSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationBachelierCapFloorEngine = {"_p_YoYInflationBachelierCapFloorEngine", "YoYInflationBachelierCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationBlackCapFloorEngine = {"_p_YoYInflationBlackCapFloorEngine", "YoYInflationBlackCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationCap = {"_p_YoYInflationCap", "YoYInflationCap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationCapFloor = {"_p_YoYInflationCapFloor", "YoYInflationCapFloor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationCapFloorTermPriceSurface = {"_p_YoYInflationCapFloorTermPriceSurface", "YoYInflationCapFloorTermPriceSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationCollar = {"_p_YoYInflationCollar", "YoYInflationCollar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationFloor = {"_p_YoYInflationFloor", "YoYInflationFloor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationIndex = {"_p_YoYInflationIndex", "YoYInflationIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationTermStructure = {"_p_YoYInflationTermStructure", "YoYInflationTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYInflationUnitDisplacedBlackCapFloorEngine = {"_p_YoYInflationUnitDisplacedBlackCapFloorEngine", "YoYInflationUnitDisplacedBlackCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYOptionletHelper = {"_p_YoYOptionletHelper", "YoYOptionletHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYOptionletStripper = {"_p_YoYOptionletStripper", "YoYOptionletStripper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_YoYOptionletVolatilitySurface = {"_p_YoYOptionletVolatilitySurface", "YoYOptionletVolatilitySurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZACPI = {"_p_ZACPI", "ZACPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrFullFd = {"_p_ZabrFullFd", "ZabrFullFd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t = {"_p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t", "ZabrInterpolatedSmileSection< ZabrFullFd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t = {"_p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t", "ZabrInterpolatedSmileSection< ZabrLocalVolatility > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t = {"_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t", "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t = {"_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t", "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrLocalVolatility = {"_p_ZabrLocalVolatility", "ZabrLocalVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrShortMaturityLognormal = {"_p_ZabrShortMaturityLognormal", "ZabrShortMaturityLognormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrShortMaturityNormal = {"_p_ZabrShortMaturityNormal", "ZabrShortMaturityNormal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrSmileSectionT_ZabrFullFd_t = {"_p_ZabrSmileSectionT_ZabrFullFd_t", "ZabrSmileSection< ZabrFullFd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrSmileSectionT_ZabrLocalVolatility_t = {"_p_ZabrSmileSectionT_ZabrLocalVolatility_t", "ZabrSmileSection< ZabrLocalVolatility > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t = {"_p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t", "ZabrSmileSection< ZabrShortMaturityLognormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t = {"_p_ZabrSmileSectionT_ZabrShortMaturityNormal_t", "ZabrSmileSection< ZabrShortMaturityNormal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroCouponBond = {"_p_ZeroCouponBond", "ZeroCouponBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroCouponInflationSwap = {"_p_ZeroCouponInflationSwap", "ZeroCouponInflationSwap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroCouponInflationSwapHelper = {"_p_ZeroCouponInflationSwapHelper", "ZeroCouponInflationSwapHelper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroInflationIndex = {"_p_ZeroInflationIndex", "ZeroInflationIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroInflationTermStructure = {"_p_ZeroInflationTermStructure", "ZeroInflationTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroSpreadedTermStructure = {"_p_ZeroSpreadedTermStructure", "ZeroSpreadedTermStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ZeroYield = {"_p_ZeroYield", "ZeroYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Zibor = {"_p_Zibor", "Zibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__GlobalBootstrap = {"_p__GlobalBootstrap", "_GlobalBootstrap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__IterativeBootstrap = {"_p__IterativeBootstrap", "_IterativeBootstrap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "Rate *|Time *|double *|Spread *|Decimal *|DiscountFactor *|Real *|Probability *|Volatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__functionT_double_fdoubleF_t = {"_p_ext__functionT_double_fdoubleF_t", "ext::function< Real (Real) > *|ext::function< double (double) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AUCPI_t = {"_p_ext__shared_ptrT_AUCPI_t", "ext::shared_ptr< AUCPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AUDLibor_t = {"_p_ext__shared_ptrT_AUDLibor_t", "ext::shared_ptr< AUDLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AmericanExercise_t = {"_p_ext__shared_ptrT_AmericanExercise_t", "ext::shared_ptr< AmericanExercise > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AmortizingFixedRateBond_t = {"_p_ext__shared_ptrT_AmortizingFixedRateBond_t", "ext::shared_ptr< AmortizingFixedRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AmortizingFloatingRateBond_t = {"_p_ext__shared_ptrT_AmortizingFloatingRateBond_t", "ext::shared_ptr< AmortizingFloatingRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AmortizingPayment_t = {"_p_ext__shared_ptrT_AmortizingPayment_t", "ext::shared_ptr< AmortizingPayment > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t = {"_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t", "ext::shared_ptr< AnalyticBSMHullWhiteEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticBarrierEngine_t = {"_p_ext__shared_ptrT_AnalyticBarrierEngine_t", "ext::shared_ptr< AnalyticBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t = {"_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t", "ext::shared_ptr< AnalyticBinaryBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticCEVEngine_t = {"_p_ext__shared_ptrT_AnalyticCEVEngine_t", "ext::shared_ptr< AnalyticCEVEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticCapFloorEngine_t = {"_p_ext__shared_ptrT_AnalyticCapFloorEngine_t", "ext::shared_ptr< AnalyticCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t = {"_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t", "ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t = {"_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t", "ext::shared_ptr< AnalyticDigitalAmericanEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t = {"_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t", "ext::shared_ptr< AnalyticDigitalAmericanKOEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t = {"_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t", "ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t = {"_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t", "ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t = {"_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t", "ext::shared_ptr< AnalyticDividendEuropeanEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t = {"_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t", "ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t = {"_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t", "ext::shared_ptr< AnalyticDoubleBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticEuropeanEngine_t = {"_p_ext__shared_ptrT_AnalyticEuropeanEngine_t", "ext::shared_ptr< AnalyticEuropeanEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t = {"_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t", "ext::shared_ptr< AnalyticGJRGARCHEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticHaganPricer_t = {"_p_ext__shared_ptrT_AnalyticHaganPricer_t", "ext::shared_ptr< AnalyticHaganPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticHestonEngine_t = {"_p_ext__shared_ptrT_AnalyticHestonEngine_t", "ext::shared_ptr< AnalyticHestonEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t = {"_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t", "ext::shared_ptr< AnalyticPTDHestonEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t = {"_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t", "ext::shared_ptr< AndreasenHugeLocalVolAdapter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t = {"_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t", "ext::shared_ptr< AndreasenHugeVolatilityAdapter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t = {"_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t", "ext::shared_ptr< AndreasenHugeVolatilityInterpl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Aonia_t = {"_p_ext__shared_ptrT_Aonia_t", "ext::shared_ptr< Aonia > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AssetOrNothingPayoff_t = {"_p_ext__shared_ptrT_AssetOrNothingPayoff_t", "ext::shared_ptr< AssetOrNothingPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AssetSwap_t = {"_p_ext__shared_ptrT_AssetSwap_t", "ext::shared_ptr< AssetSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_AverageBasketPayoff_t = {"_p_ext__shared_ptrT_AverageBasketPayoff_t", "ext::shared_ptr< AverageBasketPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BFGS_t = {"_p_ext__shared_ptrT_BFGS_t", "ext::shared_ptr< BFGS > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BSMRNDCalculator_t = {"_p_ext__shared_ptrT_BSMRNDCalculator_t", "ext::shared_ptr< BSMRNDCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BachelierCapFloorEngine_t = {"_p_ext__shared_ptrT_BachelierCapFloorEngine_t", "ext::shared_ptr< BachelierCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BachelierSwaptionEngine_t = {"_p_ext__shared_ptrT_BachelierSwaptionEngine_t", "ext::shared_ptr< BachelierSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t = {"_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t", "ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BarrierOption_t = {"_p_ext__shared_ptrT_BarrierOption_t", "ext::shared_ptr< BarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BasketOption_t = {"_p_ext__shared_ptrT_BasketOption_t", "ext::shared_ptr< BasketOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BasketPayoff_t = {"_p_ext__shared_ptrT_BasketPayoff_t", "ext::shared_ptr< BasketPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BatesEngine_t = {"_p_ext__shared_ptrT_BatesEngine_t", "ext::shared_ptr< BatesEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BatesModel_t = {"_p_ext__shared_ptrT_BatesModel_t", "ext::shared_ptr< BatesModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BatesProcess_t = {"_p_ext__shared_ptrT_BatesProcess_t", "ext::shared_ptr< BatesProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw1M_t = {"_p_ext__shared_ptrT_Bbsw1M_t", "ext::shared_ptr< Bbsw1M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw2M_t = {"_p_ext__shared_ptrT_Bbsw2M_t", "ext::shared_ptr< Bbsw2M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw3M_t = {"_p_ext__shared_ptrT_Bbsw3M_t", "ext::shared_ptr< Bbsw3M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw4M_t = {"_p_ext__shared_ptrT_Bbsw4M_t", "ext::shared_ptr< Bbsw4M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw5M_t = {"_p_ext__shared_ptrT_Bbsw5M_t", "ext::shared_ptr< Bbsw5M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw6M_t = {"_p_ext__shared_ptrT_Bbsw6M_t", "ext::shared_ptr< Bbsw6M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bbsw_t = {"_p_ext__shared_ptrT_Bbsw_t", "ext::shared_ptr< Bbsw > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BermudanExercise_t = {"_p_ext__shared_ptrT_BermudanExercise_t", "ext::shared_ptr< BermudanExercise > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BiCGstab_t = {"_p_ext__shared_ptrT_BiCGstab_t", "ext::shared_ptr< BiCGstab > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor1M_t = {"_p_ext__shared_ptrT_Bibor1M_t", "ext::shared_ptr< Bibor1M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor1Y_t = {"_p_ext__shared_ptrT_Bibor1Y_t", "ext::shared_ptr< Bibor1Y > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor2M_t = {"_p_ext__shared_ptrT_Bibor2M_t", "ext::shared_ptr< Bibor2M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor3M_t = {"_p_ext__shared_ptrT_Bibor3M_t", "ext::shared_ptr< Bibor3M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor6M_t = {"_p_ext__shared_ptrT_Bibor6M_t", "ext::shared_ptr< Bibor6M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor9M_t = {"_p_ext__shared_ptrT_Bibor9M_t", "ext::shared_ptr< Bibor9M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BiborSW_t = {"_p_ext__shared_ptrT_BiborSW_t", "ext::shared_ptr< BiborSW > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bibor_t = {"_p_ext__shared_ptrT_Bibor_t", "ext::shared_ptr< Bibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t", "ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t", "ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t", "ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t", "ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t", "ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t", "ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t", "ext::shared_ptr< BinomialConvertibleEngine< Tian > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t = {"_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t", "ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t = {"_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t", "ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t", "ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t", "ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t", "ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t", "ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t", "ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t", "ext::shared_ptr< BinomialVanillaEngine< Tian > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t = {"_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t", "ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t = {"_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t", "ext::shared_ptr< BjerksundStenslandApproximationEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm1M_t = {"_p_ext__shared_ptrT_Bkbm1M_t", "ext::shared_ptr< Bkbm1M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm2M_t = {"_p_ext__shared_ptrT_Bkbm2M_t", "ext::shared_ptr< Bkbm2M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm3M_t = {"_p_ext__shared_ptrT_Bkbm3M_t", "ext::shared_ptr< Bkbm3M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm4M_t = {"_p_ext__shared_ptrT_Bkbm4M_t", "ext::shared_ptr< Bkbm4M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm5M_t = {"_p_ext__shared_ptrT_Bkbm5M_t", "ext::shared_ptr< Bkbm5M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm6M_t = {"_p_ext__shared_ptrT_Bkbm6M_t", "ext::shared_ptr< Bkbm6M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bkbm_t = {"_p_ext__shared_ptrT_Bkbm_t", "ext::shared_ptr< Bkbm > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackCalibrationHelper_t = {"_p_ext__shared_ptrT_BlackCalibrationHelper_t", "ext::shared_ptr< BlackCalibrationHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t = {"_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t", "ext::shared_ptr< BlackCallableFixedRateBondEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackCapFloorEngine_t = {"_p_ext__shared_ptrT_BlackCapFloorEngine_t", "ext::shared_ptr< BlackCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackCdsOptionEngine_t = {"_p_ext__shared_ptrT_BlackCdsOptionEngine_t", "ext::shared_ptr< BlackCdsOptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackConstantVol_t = {"_p_ext__shared_ptrT_BlackConstantVol_t", "ext::shared_ptr< BlackConstantVol > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackIborCouponPricer_t = {"_p_ext__shared_ptrT_BlackIborCouponPricer_t", "ext::shared_ptr< BlackIborCouponPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackKarasinski_t = {"_p_ext__shared_ptrT_BlackKarasinski_t", "ext::shared_ptr< BlackKarasinski > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackProcess_t = {"_p_ext__shared_ptrT_BlackProcess_t", "ext::shared_ptr< BlackProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t = {"_p_ext__shared_ptrT_BlackScholesMertonProcess_t", "ext::shared_ptr< BlackScholesMertonProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackScholesProcess_t = {"_p_ext__shared_ptrT_BlackScholesProcess_t", "ext::shared_ptr< BlackScholesProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackSwaptionEngine_t = {"_p_ext__shared_ptrT_BlackSwaptionEngine_t", "ext::shared_ptr< BlackSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackVarianceCurve_t = {"_p_ext__shared_ptrT_BlackVarianceCurve_t", "ext::shared_ptr< BlackVarianceCurve > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackVarianceSurface_t = {"_p_ext__shared_ptrT_BlackVarianceSurface_t", "ext::shared_ptr< BlackVarianceSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BlackVolTermStructure_t = {"_p_ext__shared_ptrT_BlackVolTermStructure_t", "ext::shared_ptr< BlackVolTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BondHelper_t = {"_p_ext__shared_ptrT_BondHelper_t", "ext::shared_ptr< BondHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Bond_t = {"_p_ext__shared_ptrT_Bond_t", "ext::shared_ptr< Bond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t = {"_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t", "ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t = {"_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t", "ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t = {"_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t", "ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BoundaryConstraint_t = {"_p_ext__shared_ptrT_BoundaryConstraint_t", "ext::shared_ptr< BoundaryConstraint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_BrownianGeneratorFactory_t = {"_p_ext__shared_ptrT_BrownianGeneratorFactory_t", "ext::shared_ptr< BrownianGeneratorFactory > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CADLiborON_t = {"_p_ext__shared_ptrT_CADLiborON_t", "ext::shared_ptr< CADLiborON > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CADLibor_t = {"_p_ext__shared_ptrT_CADLibor_t", "ext::shared_ptr< CADLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CEVRNDCalculator_t = {"_p_ext__shared_ptrT_CEVRNDCalculator_t", "ext::shared_ptr< CEVRNDCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CHFLibor_t = {"_p_ext__shared_ptrT_CHFLibor_t", "ext::shared_ptr< CHFLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_COSHestonEngine_t = {"_p_ext__shared_ptrT_COSHestonEngine_t", "ext::shared_ptr< COSHestonEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CPIBond_t = {"_p_ext__shared_ptrT_CPIBond_t", "ext::shared_ptr< CPIBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CPICoupon_t = {"_p_ext__shared_ptrT_CPICoupon_t", "ext::shared_ptr< CPICoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CPISwap_t = {"_p_ext__shared_ptrT_CPISwap_t", "ext::shared_ptr< CPISwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CalibratedModel_t = {"_p_ext__shared_ptrT_CalibratedModel_t", "ext::shared_ptr< CalibratedModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CalibrationHelper_t = {"_p_ext__shared_ptrT_CalibrationHelper_t", "ext::shared_ptr< CalibrationHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Callability_t = {"_p_ext__shared_ptrT_Callability_t", "ext::shared_ptr< Callability > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CallableBond_t = {"_p_ext__shared_ptrT_CallableBond_t", "ext::shared_ptr< CallableBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CallableFixedRateBond_t = {"_p_ext__shared_ptrT_CallableFixedRateBond_t", "ext::shared_ptr< CallableFixedRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t = {"_p_ext__shared_ptrT_CallableZeroCouponBond_t", "ext::shared_ptr< CallableZeroCouponBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t = {"_p_ext__shared_ptrT_CapFloorTermVolCurve_t", "ext::shared_ptr< CapFloorTermVolCurve > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t = {"_p_ext__shared_ptrT_CapFloorTermVolSurface_t", "ext::shared_ptr< CapFloorTermVolSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t = {"_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t", "ext::shared_ptr< CapFloorTermVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CapFloor_t = {"_p_ext__shared_ptrT_CapFloor_t", "ext::shared_ptr< CapFloor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CapHelper_t = {"_p_ext__shared_ptrT_CapHelper_t", "ext::shared_ptr< CapHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Cap_t = {"_p_ext__shared_ptrT_Cap_t", "ext::shared_ptr< Cap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t = {"_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t", "ext::shared_ptr< CappedFlooredCmsCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t = {"_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t", "ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t = {"_p_ext__shared_ptrT_CappedFlooredCoupon_t", "ext::shared_ptr< CappedFlooredCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t = {"_p_ext__shared_ptrT_CappedFlooredIborCoupon_t", "ext::shared_ptr< CappedFlooredIborCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CashFlow_t = {"_p_ext__shared_ptrT_CashFlow_t", "ext::shared_ptr< CashFlow > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CashOrNothingPayoff_t = {"_p_ext__shared_ptrT_CashOrNothingPayoff_t", "ext::shared_ptr< CashOrNothingPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Cdor_t = {"_p_ext__shared_ptrT_Cdor_t", "ext::shared_ptr< Cdor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CdsOption_t = {"_p_ext__shared_ptrT_CdsOption_t", "ext::shared_ptr< CdsOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t = {"_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t", "ext::shared_ptr< ChfLiborSwapIsdaFix > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Claim_t = {"_p_ext__shared_ptrT_Claim_t", "ext::shared_ptr< Claim > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CmsCouponPricer_t = {"_p_ext__shared_ptrT_CmsCouponPricer_t", "ext::shared_ptr< CmsCouponPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CmsCoupon_t = {"_p_ext__shared_ptrT_CmsCoupon_t", "ext::shared_ptr< CmsCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CmsMarket_t = {"_p_ext__shared_ptrT_CmsMarket_t", "ext::shared_ptr< CmsMarket > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CmsRateBond_t = {"_p_ext__shared_ptrT_CmsRateBond_t", "ext::shared_ptr< CmsRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CmsSpreadCouponPricer_t = {"_p_ext__shared_ptrT_CmsSpreadCouponPricer_t", "ext::shared_ptr< CmsSpreadCouponPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t = {"_p_ext__shared_ptrT_CmsSpreadCoupon_t", "ext::shared_ptr< CmsSpreadCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Collar_t = {"_p_ext__shared_ptrT_Collar_t", "ext::shared_ptr< Collar > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CompositeConstraint_t = {"_p_ext__shared_ptrT_CompositeConstraint_t", "ext::shared_ptr< CompositeConstraint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CompositeInstrument_t = {"_p_ext__shared_ptrT_CompositeInstrument_t", "ext::shared_ptr< CompositeInstrument > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t = {"_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t", "ext::shared_ptr< CompositeQuote< BinaryFunction > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Concentrating1dMesher_t = {"_p_ext__shared_ptrT_Concentrating1dMesher_t", "ext::shared_ptr< Concentrating1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConjugateGradient_t = {"_p_ext__shared_ptrT_ConjugateGradient_t", "ext::shared_ptr< ConjugateGradient > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t = {"_p_ext__shared_ptrT_ConstantOptionletVolatility_t", "ext::shared_ptr< ConstantOptionletVolatility > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t = {"_p_ext__shared_ptrT_ConstantSwaptionVolatility_t", "ext::shared_ptr< ConstantSwaptionVolatility > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t = {"_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t", "ext::shared_ptr< ConstantYoYOptionletVolatility > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Constraint_t = {"_p_ext__shared_ptrT_Constraint_t", "ext::shared_ptr< Constraint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t = {"_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t", "ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t = {"_p_ext__shared_ptrT_ContinuousAveragingAsianOption_t", "ext::shared_ptr< ContinuousAveragingAsianOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t = {"_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t", "ext::shared_ptr< ConvertibleFixedCouponBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t = {"_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t", "ext::shared_ptr< ConvertibleFloatingRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t = {"_p_ext__shared_ptrT_ConvertibleZeroCouponBond_t", "ext::shared_ptr< ConvertibleZeroCouponBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Coupon_t = {"_p_ext__shared_ptrT_Coupon_t", "ext::shared_ptr< Coupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CoxIngersollRoss_t = {"_p_ext__shared_ptrT_CoxIngersollRoss_t", "ext::shared_ptr< CoxIngersollRoss > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CraigSneydScheme_t = {"_p_ext__shared_ptrT_CraigSneydScheme_t", "ext::shared_ptr< CraigSneydScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CrankNicolsonScheme_t = {"_p_ext__shared_ptrT_CrankNicolsonScheme_t", "ext::shared_ptr< CrankNicolsonScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_CreditDefaultSwap_t = {"_p_ext__shared_ptrT_CreditDefaultSwap_t", "ext::shared_ptr< CreditDefaultSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DKKLibor_t = {"_p_ext__shared_ptrT_DKKLibor_t", "ext::shared_ptr< DKKLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DailyTenorLibor_t = {"_p_ext__shared_ptrT_DailyTenorLibor_t", "ext::shared_ptr< DailyTenorLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DatedOISRateHelper_t = {"_p_ext__shared_ptrT_DatedOISRateHelper_t", "ext::shared_ptr< DatedOISRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DefaultBoundaryCondition_t = {"_p_ext__shared_ptrT_DefaultBoundaryCondition_t", "ext::shared_ptr< DefaultBoundaryCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DefaultProbabilityHelper_t = {"_p_ext__shared_ptrT_DefaultProbabilityHelper_t", "ext::shared_ptr< DefaultProbabilityHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t = {"_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t", "ext::shared_ptr< DefaultProbabilityTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DeltaVolQuote_t = {"_p_ext__shared_ptrT_DeltaVolQuote_t", "ext::shared_ptr< DeltaVolQuote > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DepositRateHelper_t = {"_p_ext__shared_ptrT_DepositRateHelper_t", "ext::shared_ptr< DepositRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t = {"_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t", "ext::shared_ptr< DerivedQuote< UnaryFunction > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DifferentialEvolution_t = {"_p_ext__shared_ptrT_DifferentialEvolution_t", "ext::shared_ptr< DifferentialEvolution > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DirichletBC_t = {"_p_ext__shared_ptrT_DirichletBC_t", "ext::shared_ptr< DirichletBC > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DiscountingBondEngine_t = {"_p_ext__shared_ptrT_DiscountingBondEngine_t", "ext::shared_ptr< DiscountingBondEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DiscountingSwapEngine_t = {"_p_ext__shared_ptrT_DiscountingSwapEngine_t", "ext::shared_ptr< DiscountingSwapEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t = {"_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t", "ext::shared_ptr< DiscreteAveragingAsianOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DividendBarrierOption_t = {"_p_ext__shared_ptrT_DividendBarrierOption_t", "ext::shared_ptr< DividendBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DividendVanillaOption_t = {"_p_ext__shared_ptrT_DividendVanillaOption_t", "ext::shared_ptr< DividendVanillaOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Dividend_t = {"_p_ext__shared_ptrT_Dividend_t", "ext::shared_ptr< Dividend > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DoubleBarrierOption_t = {"_p_ext__shared_ptrT_DoubleBarrierOption_t", "ext::shared_ptr< DoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_DouglasScheme_t = {"_p_ext__shared_ptrT_DouglasScheme_t", "ext::shared_ptr< DouglasScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EUHICPXT_t = {"_p_ext__shared_ptrT_EUHICPXT_t", "ext::shared_ptr< EUHICPXT > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EUHICP_t = {"_p_ext__shared_ptrT_EUHICP_t", "ext::shared_ptr< EUHICP > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor10M_t = {"_p_ext__shared_ptrT_EURLibor10M_t", "ext::shared_ptr< EURLibor10M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor11M_t = {"_p_ext__shared_ptrT_EURLibor11M_t", "ext::shared_ptr< EURLibor11M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor1M_t = {"_p_ext__shared_ptrT_EURLibor1M_t", "ext::shared_ptr< EURLibor1M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor1Y_t = {"_p_ext__shared_ptrT_EURLibor1Y_t", "ext::shared_ptr< EURLibor1Y > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor2M_t = {"_p_ext__shared_ptrT_EURLibor2M_t", "ext::shared_ptr< EURLibor2M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor2W_t = {"_p_ext__shared_ptrT_EURLibor2W_t", "ext::shared_ptr< EURLibor2W > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor3M_t = {"_p_ext__shared_ptrT_EURLibor3M_t", "ext::shared_ptr< EURLibor3M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor4M_t = {"_p_ext__shared_ptrT_EURLibor4M_t", "ext::shared_ptr< EURLibor4M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor5M_t = {"_p_ext__shared_ptrT_EURLibor5M_t", "ext::shared_ptr< EURLibor5M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor6M_t = {"_p_ext__shared_ptrT_EURLibor6M_t", "ext::shared_ptr< EURLibor6M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor7M_t = {"_p_ext__shared_ptrT_EURLibor7M_t", "ext::shared_ptr< EURLibor7M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor8M_t = {"_p_ext__shared_ptrT_EURLibor8M_t", "ext::shared_ptr< EURLibor8M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor9M_t = {"_p_ext__shared_ptrT_EURLibor9M_t", "ext::shared_ptr< EURLibor9M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLiborSW_t = {"_p_ext__shared_ptrT_EURLiborSW_t", "ext::shared_ptr< EURLiborSW > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EURLibor_t = {"_p_ext__shared_ptrT_EURLibor_t", "ext::shared_ptr< EURLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EndCriteria_t = {"_p_ext__shared_ptrT_EndCriteria_t", "ext::shared_ptr< EndCriteria > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Eonia_t = {"_p_ext__shared_ptrT_Eonia_t", "ext::shared_ptr< Eonia > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t = {"_p_ext__shared_ptrT_EurLiborSwapIfrFix_t", "ext::shared_ptr< EurLiborSwapIfrFix > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t = {"_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t", "ext::shared_ptr< EurLiborSwapIsdaFixA > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t = {"_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t", "ext::shared_ptr< EurLiborSwapIsdaFixB > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor10M_t = {"_p_ext__shared_ptrT_Euribor10M_t", "ext::shared_ptr< Euribor10M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor11M_t = {"_p_ext__shared_ptrT_Euribor11M_t", "ext::shared_ptr< Euribor11M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor1M_t = {"_p_ext__shared_ptrT_Euribor1M_t", "ext::shared_ptr< Euribor1M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor1Y_t = {"_p_ext__shared_ptrT_Euribor1Y_t", "ext::shared_ptr< Euribor1Y > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor2M_t = {"_p_ext__shared_ptrT_Euribor2M_t", "ext::shared_ptr< Euribor2M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor2W_t = {"_p_ext__shared_ptrT_Euribor2W_t", "ext::shared_ptr< Euribor2W > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_10M_t = {"_p_ext__shared_ptrT_Euribor365_10M_t", "ext::shared_ptr< Euribor365_10M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_11M_t = {"_p_ext__shared_ptrT_Euribor365_11M_t", "ext::shared_ptr< Euribor365_11M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_1M_t = {"_p_ext__shared_ptrT_Euribor365_1M_t", "ext::shared_ptr< Euribor365_1M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_1Y_t = {"_p_ext__shared_ptrT_Euribor365_1Y_t", "ext::shared_ptr< Euribor365_1Y > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_2M_t = {"_p_ext__shared_ptrT_Euribor365_2M_t", "ext::shared_ptr< Euribor365_2M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_2W_t = {"_p_ext__shared_ptrT_Euribor365_2W_t", "ext::shared_ptr< Euribor365_2W > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_3M_t = {"_p_ext__shared_ptrT_Euribor365_3M_t", "ext::shared_ptr< Euribor365_3M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_3W_t = {"_p_ext__shared_ptrT_Euribor365_3W_t", "ext::shared_ptr< Euribor365_3W > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_4M_t = {"_p_ext__shared_ptrT_Euribor365_4M_t", "ext::shared_ptr< Euribor365_4M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_5M_t = {"_p_ext__shared_ptrT_Euribor365_5M_t", "ext::shared_ptr< Euribor365_5M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_6M_t = {"_p_ext__shared_ptrT_Euribor365_6M_t", "ext::shared_ptr< Euribor365_6M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_7M_t = {"_p_ext__shared_ptrT_Euribor365_7M_t", "ext::shared_ptr< Euribor365_7M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_8M_t = {"_p_ext__shared_ptrT_Euribor365_8M_t", "ext::shared_ptr< Euribor365_8M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_9M_t = {"_p_ext__shared_ptrT_Euribor365_9M_t", "ext::shared_ptr< Euribor365_9M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_SW_t = {"_p_ext__shared_ptrT_Euribor365_SW_t", "ext::shared_ptr< Euribor365_SW > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor365_t = {"_p_ext__shared_ptrT_Euribor365_t", "ext::shared_ptr< Euribor365 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor3M_t = {"_p_ext__shared_ptrT_Euribor3M_t", "ext::shared_ptr< Euribor3M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor3W_t = {"_p_ext__shared_ptrT_Euribor3W_t", "ext::shared_ptr< Euribor3W > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor4M_t = {"_p_ext__shared_ptrT_Euribor4M_t", "ext::shared_ptr< Euribor4M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor5M_t = {"_p_ext__shared_ptrT_Euribor5M_t", "ext::shared_ptr< Euribor5M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor6M_t = {"_p_ext__shared_ptrT_Euribor6M_t", "ext::shared_ptr< Euribor6M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor7M_t = {"_p_ext__shared_ptrT_Euribor7M_t", "ext::shared_ptr< Euribor7M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor8M_t = {"_p_ext__shared_ptrT_Euribor8M_t", "ext::shared_ptr< Euribor8M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor9M_t = {"_p_ext__shared_ptrT_Euribor9M_t", "ext::shared_ptr< Euribor9M > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EuriborSW_t = {"_p_ext__shared_ptrT_EuriborSW_t", "ext::shared_ptr< EuriborSW > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t = {"_p_ext__shared_ptrT_EuriborSwapIfrFix_t", "ext::shared_ptr< EuriborSwapIfrFix > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t = {"_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t", "ext::shared_ptr< EuriborSwapIsdaFixA > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t = {"_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t", "ext::shared_ptr< EuriborSwapIsdaFixB > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Euribor_t = {"_p_ext__shared_ptrT_Euribor_t", "ext::shared_ptr< Euribor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EuropeanExercise_t = {"_p_ext__shared_ptrT_EuropeanExercise_t", "ext::shared_ptr< EuropeanExercise > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EuropeanOption_t = {"_p_ext__shared_ptrT_EuropeanOption_t", "ext::shared_ptr< EuropeanOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_EverestOption_t = {"_p_ext__shared_ptrT_EverestOption_t", "ext::shared_ptr< EverestOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Exercise_t = {"_p_ext__shared_ptrT_Exercise_t", "ext::shared_ptr< Exercise > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ExplicitEulerScheme_t = {"_p_ext__shared_ptrT_ExplicitEulerScheme_t", "ext::shared_ptr< ExplicitEulerScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t = {"_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t", "ext::shared_ptr< ExponentialFittingHestonEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ExponentialJump1dMesher_t = {"_p_ext__shared_ptrT_ExponentialJump1dMesher_t", "ext::shared_ptr< ExponentialJump1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t = {"_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t", "ext::shared_ptr< ExtOUWithJumpsProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t = {"_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t", "ext::shared_ptr< ExtendedCoxIngersollRoss > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t = {"_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t", "ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t = {"_p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t", "ext::shared_ptr< FDAmericanEngine< CrankNicolson > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t = {"_p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t", "ext::shared_ptr< FDBermudanEngine< CrankNicolson > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t = {"_p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t", "ext::shared_ptr< FDDividendAmericanEngine< CrankNicolson > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t = {"_p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t", "ext::shared_ptr< FDDividendEuropeanEngine< CrankNicolson > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t = {"_p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t", "ext::shared_ptr< FDEuropeanEngine< CrankNicolson > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t = {"_p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t", "ext::shared_ptr< FDShoutEngine< CrankNicolson > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FFTVarianceGammaEngine_t = {"_p_ext__shared_ptrT_FFTVarianceGammaEngine_t", "ext::shared_ptr< FFTVarianceGammaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FRHICP_t = {"_p_ext__shared_ptrT_FRHICP_t", "ext::shared_ptr< FRHICP > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FaceValueAccrualClaim_t = {"_p_ext__shared_ptrT_FaceValueAccrualClaim_t", "ext::shared_ptr< FaceValueAccrualClaim > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FaceValueClaim_t = {"_p_ext__shared_ptrT_FaceValueClaim_t", "ext::shared_ptr< FaceValueClaim > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t = {"_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t", "ext::shared_ptr< Fd2dBlackScholesVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdBatesVanillaEngine_t = {"_p_ext__shared_ptrT_FdBatesVanillaEngine_t", "ext::shared_ptr< FdBatesVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t = {"_p_ext__shared_ptrT_FdBlackScholesAsianEngine_t", "ext::shared_ptr< FdBlackScholesAsianEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t = {"_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t", "ext::shared_ptr< FdBlackScholesBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t = {"_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t", "ext::shared_ptr< FdBlackScholesRebateEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t = {"_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t", "ext::shared_ptr< FdBlackScholesVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdCEVVanillaEngine_t = {"_p_ext__shared_ptrT_FdCEVVanillaEngine_t", "ext::shared_ptr< FdCEVVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdG2SwaptionEngine_t = {"_p_ext__shared_ptrT_FdG2SwaptionEngine_t", "ext::shared_ptr< FdG2SwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdHestonBarrierEngine_t = {"_p_ext__shared_ptrT_FdHestonBarrierEngine_t", "ext::shared_ptr< FdHestonBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t = {"_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t", "ext::shared_ptr< FdHestonDoubleBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdHestonRebateEngine_t = {"_p_ext__shared_ptrT_FdHestonRebateEngine_t", "ext::shared_ptr< FdHestonRebateEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdHestonVanillaEngine_t = {"_p_ext__shared_ptrT_FdHestonVanillaEngine_t", "ext::shared_ptr< FdHestonVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t = {"_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t", "ext::shared_ptr< FdHullWhiteSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t = {"_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t", "ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdSabrVanillaEngine_t = {"_p_ext__shared_ptrT_FdSabrVanillaEngine_t", "ext::shared_ptr< FdSabrVanillaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t = {"_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t", "ext::shared_ptr< FdSimpleBSSwingEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t = {"_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t", "ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fdm1DimSolver_t = {"_p_ext__shared_ptrT_Fdm1DimSolver_t", "ext::shared_ptr< Fdm1DimSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fdm1dMesher_t = {"_p_ext__shared_ptrT_Fdm1dMesher_t", "ext::shared_ptr< Fdm1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fdm2DimSolver_t = {"_p_ext__shared_ptrT_Fdm2DimSolver_t", "ext::shared_ptr< Fdm2DimSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t = {"_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t", "ext::shared_ptr< Fdm2dBlackScholesOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t = {"_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t", "ext::shared_ptr< Fdm2dBlackScholesSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Fdm3DimSolver_t = {"_p_ext__shared_ptrT_Fdm3DimSolver_t", "ext::shared_ptr< Fdm3DimSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t = {"_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t", "ext::shared_ptr< FdmAffineModelSwapInnerValue< G2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t = {"_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t", "ext::shared_ptr< FdmAffineModelSwapInnerValue< HullWhite > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmAmericanStepCondition_t = {"_p_ext__shared_ptrT_FdmAmericanStepCondition_t", "ext::shared_ptr< FdmAmericanStepCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmArithmeticAverageCondition_t = {"_p_ext__shared_ptrT_FdmArithmeticAverageCondition_t", "ext::shared_ptr< FdmArithmeticAverageCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBackwardSolver_t = {"_p_ext__shared_ptrT_FdmBackwardSolver_t", "ext::shared_ptr< FdmBackwardSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBatesOp_t = {"_p_ext__shared_ptrT_FdmBatesOp_t", "ext::shared_ptr< FdmBatesOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBermudanStepCondition_t = {"_p_ext__shared_ptrT_FdmBermudanStepCondition_t", "ext::shared_ptr< FdmBermudanStepCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t = {"_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t", "ext::shared_ptr< FdmBlackScholesFwdOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBlackScholesMesher_t = {"_p_ext__shared_ptrT_FdmBlackScholesMesher_t", "ext::shared_ptr< FdmBlackScholesMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBlackScholesOp_t = {"_p_ext__shared_ptrT_FdmBlackScholesOp_t", "ext::shared_ptr< FdmBlackScholesOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmBoundaryCondition_t = {"_p_ext__shared_ptrT_FdmBoundaryCondition_t", "ext::shared_ptr< FdmBoundaryCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmCEV1dMesher_t = {"_p_ext__shared_ptrT_FdmCEV1dMesher_t", "ext::shared_ptr< FdmCEV1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmCEVOp_t = {"_p_ext__shared_ptrT_FdmCEVOp_t", "ext::shared_ptr< FdmCEVOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmCellAveragingInnerValue_t = {"_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t", "ext::shared_ptr< FdmCellAveragingInnerValue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmDirichletBoundary_t = {"_p_ext__shared_ptrT_FdmDirichletBoundary_t", "ext::shared_ptr< FdmDirichletBoundary > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t = {"_p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t", "ext::shared_ptr< FdmDiscountDirichletBoundary > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmDividendHandler_t = {"_p_ext__shared_ptrT_FdmDividendHandler_t", "ext::shared_ptr< FdmDividendHandler > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmDupire1dOp_t = {"_p_ext__shared_ptrT_FdmDupire1dOp_t", "ext::shared_ptr< FdmDupire1dOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmG2Op_t = {"_p_ext__shared_ptrT_FdmG2Op_t", "ext::shared_ptr< FdmG2Op > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmG2Solver_t = {"_p_ext__shared_ptrT_FdmG2Solver_t", "ext::shared_ptr< FdmG2Solver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonFwdOp_t = {"_p_ext__shared_ptrT_FdmHestonFwdOp_t", "ext::shared_ptr< FdmHestonFwdOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t = {"_p_ext__shared_ptrT_FdmHestonHullWhiteOp_t", "ext::shared_ptr< FdmHestonHullWhiteOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t = {"_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t", "ext::shared_ptr< FdmHestonHullWhiteSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t = {"_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t", "ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonOp_t = {"_p_ext__shared_ptrT_FdmHestonOp_t", "ext::shared_ptr< FdmHestonOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonSolver_t = {"_p_ext__shared_ptrT_FdmHestonSolver_t", "ext::shared_ptr< FdmHestonSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHestonVarianceMesher_t = {"_p_ext__shared_ptrT_FdmHestonVarianceMesher_t", "ext::shared_ptr< FdmHestonVarianceMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHullWhiteOp_t = {"_p_ext__shared_ptrT_FdmHullWhiteOp_t", "ext::shared_ptr< FdmHullWhiteOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmHullWhiteSolver_t = {"_p_ext__shared_ptrT_FdmHullWhiteSolver_t", "ext::shared_ptr< FdmHullWhiteSolver > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmIndicesOnBoundary_t = {"_p_ext__shared_ptrT_FdmIndicesOnBoundary_t", "ext::shared_ptr< FdmIndicesOnBoundary > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t = {"_p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t", "ext::shared_ptr< FdmInnerValueCalculatorProxy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmInnerValueCalculator_t = {"_p_ext__shared_ptrT_FdmInnerValueCalculator_t", "ext::shared_ptr< FdmInnerValueCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t = {"_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t", "ext::shared_ptr< FdmLinearOpCompositeProxy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLinearOpComposite_t = {"_p_ext__shared_ptrT_FdmLinearOpComposite_t", "ext::shared_ptr< FdmLinearOpComposite > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLinearOpLayout_t = {"_p_ext__shared_ptrT_FdmLinearOpLayout_t", "ext::shared_ptr< FdmLinearOpLayout > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLinearOp_t = {"_p_ext__shared_ptrT_FdmLinearOp_t", "ext::shared_ptr< FdmLinearOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLocalVolFwdOp_t = {"_p_ext__shared_ptrT_FdmLocalVolFwdOp_t", "ext::shared_ptr< FdmLocalVolFwdOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLogBasketInnerValue_t = {"_p_ext__shared_ptrT_FdmLogBasketInnerValue_t", "ext::shared_ptr< FdmLogBasketInnerValue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmLogInnerValue_t = {"_p_ext__shared_ptrT_FdmLogInnerValue_t", "ext::shared_ptr< FdmLogInnerValue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmMesherComposite_t = {"_p_ext__shared_ptrT_FdmMesherComposite_t", "ext::shared_ptr< FdmMesherComposite > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmMesher_t = {"_p_ext__shared_ptrT_FdmMesher_t", "ext::shared_ptr< FdmMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmNdimSolverT_4_t_t = {"_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t", "ext::shared_ptr< FdmNdimSolver< 4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmNdimSolverT_5_t_t = {"_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t", "ext::shared_ptr< FdmNdimSolver< 5 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmNdimSolverT_6_t_t = {"_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t", "ext::shared_ptr< FdmNdimSolver< 6 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t = {"_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t", "ext::shared_ptr< FdmOrnsteinUhlenbeckOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmQuantoHelper_t = {"_p_ext__shared_ptrT_FdmQuantoHelper_t", "ext::shared_ptr< FdmQuantoHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmSabrOp_t = {"_p_ext__shared_ptrT_FdmSabrOp_t", "ext::shared_ptr< FdmSabrOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t = {"_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t", "ext::shared_ptr< FdmSimpleProcess1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmSimpleStorageCondition_t = {"_p_ext__shared_ptrT_FdmSimpleStorageCondition_t", "ext::shared_ptr< FdmSimpleStorageCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmSimpleSwingCondition_t = {"_p_ext__shared_ptrT_FdmSimpleSwingCondition_t", "ext::shared_ptr< FdmSimpleSwingCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmSnapshotCondition_t = {"_p_ext__shared_ptrT_FdmSnapshotCondition_t", "ext::shared_ptr< FdmSnapshotCondition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmSquareRootFwdOp_t = {"_p_ext__shared_ptrT_FdmSquareRootFwdOp_t", "ext::shared_ptr< FdmSquareRootFwdOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmStepConditionComposite_t = {"_p_ext__shared_ptrT_FdmStepConditionComposite_t", "ext::shared_ptr< FdmStepConditionComposite > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmStepConditionProxy_t = {"_p_ext__shared_ptrT_FdmStepConditionProxy_t", "ext::shared_ptr< FdmStepConditionProxy > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t = {"_p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t", "ext::shared_ptr< FdmTimeDepDirichletBoundary > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmZabrOp_t = {"_p_ext__shared_ptrT_FdmZabrOp_t", "ext::shared_ptr< FdmZabrOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FdmZeroInnerValue_t = {"_p_ext__shared_ptrT_FdmZeroInnerValue_t", "ext::shared_ptr< FdmZeroInnerValue > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FedFunds_t = {"_p_ext__shared_ptrT_FedFunds_t", "ext::shared_ptr< FedFunds > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FirstDerivativeOp_t = {"_p_ext__shared_ptrT_FirstDerivativeOp_t", "ext::shared_ptr< FirstDerivativeOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FittedBondDiscountCurve_t = {"_p_ext__shared_ptrT_FittedBondDiscountCurve_t", "ext::shared_ptr< FittedBondDiscountCurve > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FixedDividend_t = {"_p_ext__shared_ptrT_FixedDividend_t", "ext::shared_ptr< FixedDividend > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FixedRateBondForward_t = {"_p_ext__shared_ptrT_FixedRateBondForward_t", "ext::shared_ptr< FixedRateBondForward > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FixedRateBondHelper_t = {"_p_ext__shared_ptrT_FixedRateBondHelper_t", "ext::shared_ptr< FixedRateBondHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FixedRateBond_t = {"_p_ext__shared_ptrT_FixedRateBond_t", "ext::shared_ptr< FixedRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FixedRateCoupon_t = {"_p_ext__shared_ptrT_FixedRateCoupon_t", "ext::shared_ptr< FixedRateCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FlatForward_t = {"_p_ext__shared_ptrT_FlatForward_t", "ext::shared_ptr< FlatForward > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FlatHazardRate_t = {"_p_ext__shared_ptrT_FlatHazardRate_t", "ext::shared_ptr< FlatHazardRate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FlatSmileSection_t = {"_p_ext__shared_ptrT_FlatSmileSection_t", "ext::shared_ptr< FlatSmileSection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FloatFloatSwap_t = {"_p_ext__shared_ptrT_FloatFloatSwap_t", "ext::shared_ptr< FloatFloatSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FloatFloatSwaption_t = {"_p_ext__shared_ptrT_FloatFloatSwaption_t", "ext::shared_ptr< FloatFloatSwaption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FloatingRateBond_t = {"_p_ext__shared_ptrT_FloatingRateBond_t", "ext::shared_ptr< FloatingRateBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FloatingRateCouponPricer_t = {"_p_ext__shared_ptrT_FloatingRateCouponPricer_t", "ext::shared_ptr< FloatingRateCouponPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FloatingRateCoupon_t = {"_p_ext__shared_ptrT_FloatingRateCoupon_t", "ext::shared_ptr< FloatingRateCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Floor_t = {"_p_ext__shared_ptrT_Floor_t", "ext::shared_ptr< Floor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ForwardEuropeanEngine_t = {"_p_ext__shared_ptrT_ForwardEuropeanEngine_t", "ext::shared_ptr< ForwardEuropeanEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ForwardRateAgreement_t = {"_p_ext__shared_ptrT_ForwardRateAgreement_t", "ext::shared_ptr< ForwardRateAgreement > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t = {"_p_ext__shared_ptrT_ForwardSpreadedTermStructure_t", "ext::shared_ptr< ForwardSpreadedTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ForwardVanillaOption_t = {"_p_ext__shared_ptrT_ForwardVanillaOption_t", "ext::shared_ptr< ForwardVanillaOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Forward_t = {"_p_ext__shared_ptrT_Forward_t", "ext::shared_ptr< Forward > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FraRateHelper_t = {"_p_ext__shared_ptrT_FraRateHelper_t", "ext::shared_ptr< FraRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FractionalDividend_t = {"_p_ext__shared_ptrT_FractionalDividend_t", "ext::shared_ptr< FractionalDividend > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FuturesRateHelper_t = {"_p_ext__shared_ptrT_FuturesRateHelper_t", "ext::shared_ptr< FuturesRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_FxSwapRateHelper_t = {"_p_ext__shared_ptrT_FxSwapRateHelper_t", "ext::shared_ptr< FxSwapRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_G2ForwardProcess_t = {"_p_ext__shared_ptrT_G2ForwardProcess_t", "ext::shared_ptr< G2ForwardProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_G2Process_t = {"_p_ext__shared_ptrT_G2Process_t", "ext::shared_ptr< G2Process > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_G2SwaptionEngine_t = {"_p_ext__shared_ptrT_G2SwaptionEngine_t", "ext::shared_ptr< G2SwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_G2_t = {"_p_ext__shared_ptrT_G2_t", "ext::shared_ptr< G2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GBPLiborON_t = {"_p_ext__shared_ptrT_GBPLiborON_t", "ext::shared_ptr< GBPLiborON > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GBPLibor_t = {"_p_ext__shared_ptrT_GBPLibor_t", "ext::shared_ptr< GBPLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GBSMRNDCalculator_t = {"_p_ext__shared_ptrT_GBSMRNDCalculator_t", "ext::shared_ptr< GBSMRNDCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GJRGARCHModel_t = {"_p_ext__shared_ptrT_GJRGARCHModel_t", "ext::shared_ptr< GJRGARCHModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GJRGARCHProcess_t = {"_p_ext__shared_ptrT_GJRGARCHProcess_t", "ext::shared_ptr< GJRGARCHProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GMRES_t = {"_p_ext__shared_ptrT_GMRES_t", "ext::shared_ptr< GMRES > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GapPayoff_t = {"_p_ext__shared_ptrT_GapPayoff_t", "ext::shared_ptr< GapPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t = {"_p_ext__shared_ptrT_GarmanKohlagenProcess_t", "ext::shared_ptr< GarmanKohlagenProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t = {"_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t", "ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t = {"_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t", "ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Gaussian1dModel_t = {"_p_ext__shared_ptrT_Gaussian1dModel_t", "ext::shared_ptr< Gaussian1dModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t = {"_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t", "ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t = {"_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t", "ext::shared_ptr< Gaussian1dSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GaussianSimulatedAnnealing_t = {"_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t", "ext::shared_ptr< GaussianSimulatedAnnealing > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t = {"_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t", "ext::shared_ptr< GbpLiborSwapIsdaFix > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t = {"_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t", "ext::shared_ptr< GeneralizedBlackScholesProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t = {"_p_ext__shared_ptrT_GeometricBrownianMotionProcess_t", "ext::shared_ptr< GeometricBrownianMotionProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t = {"_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t", "ext::shared_ptr< GlobalLinearSimpleZeroCurve > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Glued1dMesher_t = {"_p_ext__shared_ptrT_Glued1dMesher_t", "ext::shared_ptr< Glued1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_GsrProcess_t = {"_p_ext__shared_ptrT_GsrProcess_t", "ext::shared_ptr< GsrProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Gsr_t = {"_p_ext__shared_ptrT_Gsr_t", "ext::shared_ptr< Gsr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t = {"_p_ext__shared_ptrT_HestonBlackVolSurface_t", "ext::shared_ptr< HestonBlackVolSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HestonModelHelper_t = {"_p_ext__shared_ptrT_HestonModelHelper_t", "ext::shared_ptr< HestonModelHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HestonModel_t = {"_p_ext__shared_ptrT_HestonModel_t", "ext::shared_ptr< HestonModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HestonProcess_t = {"_p_ext__shared_ptrT_HestonProcess_t", "ext::shared_ptr< HestonProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HestonRNDCalculator_t = {"_p_ext__shared_ptrT_HestonRNDCalculator_t", "ext::shared_ptr< HestonRNDCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HestonSLVProcess_t = {"_p_ext__shared_ptrT_HestonSLVProcess_t", "ext::shared_ptr< HestonSLVProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HimalayaOption_t = {"_p_ext__shared_ptrT_HimalayaOption_t", "ext::shared_ptr< HimalayaOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HullWhiteForwardProcess_t = {"_p_ext__shared_ptrT_HullWhiteForwardProcess_t", "ext::shared_ptr< HullWhiteForwardProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HullWhiteProcess_t = {"_p_ext__shared_ptrT_HullWhiteProcess_t", "ext::shared_ptr< HullWhiteProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HullWhite_t = {"_p_ext__shared_ptrT_HullWhite_t", "ext::shared_ptr< HullWhite > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_HundsdorferScheme_t = {"_p_ext__shared_ptrT_HundsdorferScheme_t", "ext::shared_ptr< HundsdorferScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IborCouponPricer_t = {"_p_ext__shared_ptrT_IborCouponPricer_t", "ext::shared_ptr< IborCouponPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IborCoupon_t = {"_p_ext__shared_ptrT_IborCoupon_t", "ext::shared_ptr< IborCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IborIndex_t = {"_p_ext__shared_ptrT_IborIndex_t", "ext::shared_ptr< IborIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ImplicitEulerScheme_t = {"_p_ext__shared_ptrT_ImplicitEulerScheme_t", "ext::shared_ptr< ImplicitEulerScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ImpliedTermStructure_t = {"_p_ext__shared_ptrT_ImpliedTermStructure_t", "ext::shared_ptr< ImpliedTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Index_t = {"_p_ext__shared_ptrT_Index_t", "ext::shared_ptr< Index > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IndexedCashFlow_t = {"_p_ext__shared_ptrT_IndexedCashFlow_t", "ext::shared_ptr< IndexedCashFlow > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InflationCoupon_t = {"_p_ext__shared_ptrT_InflationCoupon_t", "ext::shared_ptr< InflationCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InflationIndex_t = {"_p_ext__shared_ptrT_InflationIndex_t", "ext::shared_ptr< InflationIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InflationTermStructure_t = {"_p_ext__shared_ptrT_InflationTermStructure_t", "ext::shared_ptr< InflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Instrument_t = {"_p_ext__shared_ptrT_Instrument_t", "ext::shared_ptr< Instrument > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IntegralCdsEngine_t = {"_p_ext__shared_ptrT_IntegralCdsEngine_t", "ext::shared_ptr< IntegralCdsEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IntegralEngine_t = {"_p_ext__shared_ptrT_IntegralEngine_t", "ext::shared_ptr< IntegralEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterestRateIndex_t = {"_p_ext__shared_ptrT_InterestRateIndex_t", "ext::shared_ptr< InterestRateIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t", "ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t = {"_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t", "ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t", "ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t", "ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t = {"_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t", "ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t = {"_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t", "ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t = {"_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t", "ext::shared_ptr< InterpolatedPiecewiseZeroSpreadedTermStructure< BackwardFlat > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t", "ext::shared_ptr< InterpolatedPiecewiseZeroSpreadedTermStructure< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t = {"_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t", "ext::shared_ptr< InterpolatedSmileSection< Cubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t", "ext::shared_ptr< InterpolatedSmileSection< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t", "ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t", "ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t", "ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t", "ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t", "ext::shared_ptr< InterpolatedYoYOptionletStripper< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t", "ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t", "ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t", "ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t", "ext::shared_ptr< InterpolatedZeroCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t", "ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t", "ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t", "ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t = {"_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t", "ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_IsdaCdsEngine_t = {"_p_ext__shared_ptrT_IsdaCdsEngine_t", "ext::shared_ptr< IsdaCdsEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_JPYLibor_t = {"_p_ext__shared_ptrT_JPYLibor_t", "ext::shared_ptr< JPYLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_JamshidianSwaptionEngine_t = {"_p_ext__shared_ptrT_JamshidianSwaptionEngine_t", "ext::shared_ptr< JamshidianSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Jibar_t = {"_p_ext__shared_ptrT_Jibar_t", "ext::shared_ptr< Jibar > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t = {"_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t", "ext::shared_ptr< JpyLiborSwapIsdaFixAm > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t = {"_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t", "ext::shared_ptr< JpyLiborSwapIsdaFixPm > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t = {"_p_ext__shared_ptrT_JuQuadraticApproximationEngine_t", "ext::shared_ptr< JuQuadraticApproximationEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t = {"_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t", "ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_KahaleSmileSection_t = {"_p_ext__shared_ptrT_KahaleSmileSection_t", "ext::shared_ptr< KahaleSmileSection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_KerkhofSeasonality_t = {"_p_ext__shared_ptrT_KerkhofSeasonality_t", "ext::shared_ptr< KerkhofSeasonality > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_KirkEngine_t = {"_p_ext__shared_ptrT_KirkEngine_t", "ext::shared_ptr< KirkEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_KirkSpreadOptionEngine_t = {"_p_ext__shared_ptrT_KirkSpreadOptionEngine_t", "ext::shared_ptr< KirkSpreadOptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_KlugeExtOUProcess_t = {"_p_ext__shared_ptrT_KlugeExtOUProcess_t", "ext::shared_ptr< KlugeExtOUProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LevenbergMarquardt_t = {"_p_ext__shared_ptrT_LevenbergMarquardt_t", "ext::shared_ptr< LevenbergMarquardt > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Libor_t = {"_p_ext__shared_ptrT_Libor_t", "ext::shared_ptr< Libor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LinearTsrPricer_t = {"_p_ext__shared_ptrT_LinearTsrPricer_t", "ext::shared_ptr< LinearTsrPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LocalConstantVol_t = {"_p_ext__shared_ptrT_LocalConstantVol_t", "ext::shared_ptr< LocalConstantVol > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LocalVolRNDCalculator_t = {"_p_ext__shared_ptrT_LocalVolRNDCalculator_t", "ext::shared_ptr< LocalVolRNDCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LocalVolSurface_t = {"_p_ext__shared_ptrT_LocalVolSurface_t", "ext::shared_ptr< LocalVolSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LocalVolTermStructure_t = {"_p_ext__shared_ptrT_LocalVolTermStructure_t", "ext::shared_ptr< LocalVolTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t = {"_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t", "ext::shared_ptr< LogNormalSimulatedAnnealing > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t = {"_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t", "ext::shared_ptr< LognormalCmsSpreadPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCAmericanEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCBarrierEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCEverestEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t = {"_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t", "ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t = {"_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t", "ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MTBrownianGeneratorFactory_t = {"_p_ext__shared_ptrT_MTBrownianGeneratorFactory_t", "ext::shared_ptr< MTBrownianGeneratorFactory > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MarkovFunctional_t = {"_p_ext__shared_ptrT_MarkovFunctional_t", "ext::shared_ptr< MarkovFunctional > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MaxBasketPayoff_t = {"_p_ext__shared_ptrT_MaxBasketPayoff_t", "ext::shared_ptr< MaxBasketPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Merton76Process_t = {"_p_ext__shared_ptrT_Merton76Process_t", "ext::shared_ptr< Merton76Process > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MethodOfLinesScheme_t = {"_p_ext__shared_ptrT_MethodOfLinesScheme_t", "ext::shared_ptr< MethodOfLinesScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MidPointCdsEngine_t = {"_p_ext__shared_ptrT_MidPointCdsEngine_t", "ext::shared_ptr< MidPointCdsEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MinBasketPayoff_t = {"_p_ext__shared_ptrT_MinBasketPayoff_t", "ext::shared_ptr< MinBasketPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t = {"_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t", "ext::shared_ptr< MirrorGaussianSimulatedAnnealing > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ModifiedCraigSneydScheme_t = {"_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t", "ext::shared_ptr< ModifiedCraigSneydScheme > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Mosprime_t = {"_p_ext__shared_ptrT_Mosprime_t", "ext::shared_ptr< Mosprime > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MultiAssetOption_t = {"_p_ext__shared_ptrT_MultiAssetOption_t", "ext::shared_ptr< MultiAssetOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_MultiplicativePriceSeasonality_t = {"_p_ext__shared_ptrT_MultiplicativePriceSeasonality_t", "ext::shared_ptr< MultiplicativePriceSeasonality > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NZDLibor_t = {"_p_ext__shared_ptrT_NZDLibor_t", "ext::shared_ptr< NZDLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NeumannBC_t = {"_p_ext__shared_ptrT_NeumannBC_t", "ext::shared_ptr< NeumannBC > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NinePointLinearOp_t = {"_p_ext__shared_ptrT_NinePointLinearOp_t", "ext::shared_ptr< NinePointLinearOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t = {"_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t", "ext::shared_ptr< NoArbSabrInterpolatedSmileSection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NoArbSabrSmileSection_t = {"_p_ext__shared_ptrT_NoArbSabrSmileSection_t", "ext::shared_ptr< NoArbSabrSmileSection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NoConstraint_t = {"_p_ext__shared_ptrT_NoConstraint_t", "ext::shared_ptr< NoConstraint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t = {"_p_ext__shared_ptrT_NoExceptLocalVolSurface_t", "ext::shared_ptr< NoExceptLocalVolSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t = {"_p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t", "ext::shared_ptr< NonhomogeneousBoundaryConstraint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NonstandardSwap_t = {"_p_ext__shared_ptrT_NonstandardSwap_t", "ext::shared_ptr< NonstandardSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NonstandardSwaption_t = {"_p_ext__shared_ptrT_NonstandardSwaption_t", "ext::shared_ptr< NonstandardSwaption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NthOrderDerivativeOp_t = {"_p_ext__shared_ptrT_NthOrderDerivativeOp_t", "ext::shared_ptr< NthOrderDerivativeOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_NumericHaganPricer_t = {"_p_ext__shared_ptrT_NumericHaganPricer_t", "ext::shared_ptr< NumericHaganPricer > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Nzocr_t = {"_p_ext__shared_ptrT_Nzocr_t", "ext::shared_ptr< Nzocr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OISRateHelper_t = {"_p_ext__shared_ptrT_OISRateHelper_t", "ext::shared_ptr< OISRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Observable_t = {"_p_ext__shared_ptrT_Observable_t", "ext::shared_ptr< Observable > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OneAssetOption_t = {"_p_ext__shared_ptrT_OneAssetOption_t", "ext::shared_ptr< OneAssetOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OneFactorAffineModel_t = {"_p_ext__shared_ptrT_OneFactorAffineModel_t", "ext::shared_ptr< OneFactorAffineModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OptimizationMethod_t = {"_p_ext__shared_ptrT_OptimizationMethod_t", "ext::shared_ptr< OptimizationMethod > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Option_t = {"_p_ext__shared_ptrT_Option_t", "ext::shared_ptr< Option > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OptionletStripper1_t = {"_p_ext__shared_ptrT_OptionletStripper1_t", "ext::shared_ptr< OptionletStripper1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OptionletVolatilityStructure_t = {"_p_ext__shared_ptrT_OptionletVolatilityStructure_t", "ext::shared_ptr< OptionletVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t = {"_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t", "ext::shared_ptr< OrnsteinUhlenbeckProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t = {"_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t", "ext::shared_ptr< OvernightIndexFutureRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OvernightIndex_t = {"_p_ext__shared_ptrT_OvernightIndex_t", "ext::shared_ptr< OvernightIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t = {"_p_ext__shared_ptrT_OvernightIndexedCoupon_t", "ext::shared_ptr< OvernightIndexedCoupon > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t = {"_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t", "ext::shared_ptr< OvernightIndexedSwapIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_OvernightIndexedSwap_t = {"_p_ext__shared_ptrT_OvernightIndexedSwap_t", "ext::shared_ptr< OvernightIndexedSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Payoff_t = {"_p_ext__shared_ptrT_Payoff_t", "ext::shared_ptr< Payoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PercentageStrikePayoff_t = {"_p_ext__shared_ptrT_PercentageStrikePayoff_t", "ext::shared_ptr< PercentageStrikePayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t = {"_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t", "ext::shared_ptr< PiecewiseConvexMonotoneZero > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseCubicZero_t = {"_p_ext__shared_ptrT_PiecewiseCubicZero_t", "ext::shared_ptr< PiecewiseCubicZero > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseFlatForward_t = {"_p_ext__shared_ptrT_PiecewiseFlatForward_t", "ext::shared_ptr< PiecewiseFlatForward > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t = {"_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t", "ext::shared_ptr< PiecewiseFlatHazardRate > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t = {"_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t", "ext::shared_ptr< PiecewiseKrugerLogDiscount > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseKrugerZero_t = {"_p_ext__shared_ptrT_PiecewiseKrugerZero_t", "ext::shared_ptr< PiecewiseKrugerZero > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseLinearForward_t = {"_p_ext__shared_ptrT_PiecewiseLinearForward_t", "ext::shared_ptr< PiecewiseLinearForward > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseLinearZero_t = {"_p_ext__shared_ptrT_PiecewiseLinearZero_t", "ext::shared_ptr< PiecewiseLinearZero > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t = {"_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t", "ext::shared_ptr< PiecewiseLogCubicDiscount > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t = {"_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t", "ext::shared_ptr< PiecewiseLogLinearDiscount > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t = {"_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t", "ext::shared_ptr< PiecewiseSplineCubicDiscount > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t = {"_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t", "ext::shared_ptr< PiecewiseTimeDependentHestonModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t = {"_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t", "ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t = {"_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t", "ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PlainVanillaPayoff_t = {"_p_ext__shared_ptrT_PlainVanillaPayoff_t", "ext::shared_ptr< PlainVanillaPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PositiveConstraint_t = {"_p_ext__shared_ptrT_PositiveConstraint_t", "ext::shared_ptr< PositiveConstraint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Predefined1dMesher_t = {"_p_ext__shared_ptrT_Predefined1dMesher_t", "ext::shared_ptr< Predefined1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Pribor_t = {"_p_ext__shared_ptrT_Pribor_t", "ext::shared_ptr< Pribor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_PricingEngine_t = {"_p_ext__shared_ptrT_PricingEngine_t", "ext::shared_ptr< PricingEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t = {"_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t", "ext::shared_ptr< QuantoDoubleBarrierOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_QuantoEuropeanEngine_t = {"_p_ext__shared_ptrT_QuantoEuropeanEngine_t", "ext::shared_ptr< QuantoEuropeanEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t = {"_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t", "ext::shared_ptr< QuantoForwardEuropeanEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t = {"_p_ext__shared_ptrT_QuantoForwardVanillaOption_t", "ext::shared_ptr< QuantoForwardVanillaOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_QuantoVanillaOption_t = {"_p_ext__shared_ptrT_QuantoVanillaOption_t", "ext::shared_ptr< QuantoVanillaOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Quote_t = {"_p_ext__shared_ptrT_Quote_t", "ext::shared_ptr< Quote > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_RateHelper_t = {"_p_ext__shared_ptrT_RateHelper_t", "ext::shared_ptr< RateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_RebatedExercise_t = {"_p_ext__shared_ptrT_RebatedExercise_t", "ext::shared_ptr< RebatedExercise > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Redemption_t = {"_p_ext__shared_ptrT_Redemption_t", "ext::shared_ptr< Redemption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_RiskNeutralDensityCalculator_t = {"_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t", "ext::shared_ptr< RiskNeutralDensityCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Robor_t = {"_p_ext__shared_ptrT_Robor_t", "ext::shared_ptr< Robor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SEKLibor_t = {"_p_ext__shared_ptrT_SEKLibor_t", "ext::shared_ptr< SEKLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SabrSmileSection_t = {"_p_ext__shared_ptrT_SabrSmileSection_t", "ext::shared_ptr< SabrSmileSection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Seasonality_t = {"_p_ext__shared_ptrT_Seasonality_t", "ext::shared_ptr< Seasonality > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SecondDerivativeOp_t = {"_p_ext__shared_ptrT_SecondDerivativeOp_t", "ext::shared_ptr< SecondDerivativeOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t = {"_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t", "ext::shared_ptr< SecondOrderMixedDerivativeOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Shibor_t = {"_p_ext__shared_ptrT_Shibor_t", "ext::shared_ptr< Shibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ShortRateModel_t = {"_p_ext__shared_ptrT_ShortRateModel_t", "ext::shared_ptr< ShortRateModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SimpleCashFlow_t = {"_p_ext__shared_ptrT_SimpleCashFlow_t", "ext::shared_ptr< SimpleCashFlow > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SimpleQuote_t = {"_p_ext__shared_ptrT_SimpleQuote_t", "ext::shared_ptr< SimpleQuote > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Simplex_t = {"_p_ext__shared_ptrT_Simplex_t", "ext::shared_ptr< Simplex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SmileSection_t = {"_p_ext__shared_ptrT_SmileSection_t", "ext::shared_ptr< SmileSection > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t = {"_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t", "ext::shared_ptr< SobolBrownianGeneratorFactory > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SofrFutureRateHelper_t = {"_p_ext__shared_ptrT_SofrFutureRateHelper_t", "ext::shared_ptr< SofrFutureRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Sofr_t = {"_p_ext__shared_ptrT_Sofr_t", "ext::shared_ptr< Sofr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SoftCallability_t = {"_p_ext__shared_ptrT_SoftCallability_t", "ext::shared_ptr< SoftCallability > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Sonia_t = {"_p_ext__shared_ptrT_Sonia_t", "ext::shared_ptr< Sonia > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SpreadBasketPayoff_t = {"_p_ext__shared_ptrT_SpreadBasketPayoff_t", "ext::shared_ptr< SpreadBasketPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SpreadCdsHelper_t = {"_p_ext__shared_ptrT_SpreadCdsHelper_t", "ext::shared_ptr< SpreadCdsHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SpreadOption_t = {"_p_ext__shared_ptrT_SpreadOption_t", "ext::shared_ptr< SpreadOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t = {"_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t", "ext::shared_ptr< SquareRootProcessRNDCalculator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SteepestDescent_t = {"_p_ext__shared_ptrT_SteepestDescent_t", "ext::shared_ptr< SteepestDescent > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StepConditionT_Array_t_t = {"_p_ext__shared_ptrT_StepConditionT_Array_t_t", "ext::shared_ptr< StepCondition< Array > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StochasticProcess1D_t = {"_p_ext__shared_ptrT_StochasticProcess1D_t", "ext::shared_ptr< StochasticProcess1D > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StochasticProcessArray_t = {"_p_ext__shared_ptrT_StochasticProcessArray_t", "ext::shared_ptr< StochasticProcessArray > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StochasticProcess_t = {"_p_ext__shared_ptrT_StochasticProcess_t", "ext::shared_ptr< StochasticProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Stock_t = {"_p_ext__shared_ptrT_Stock_t", "ext::shared_ptr< Stock > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StrikedTypePayoff_t = {"_p_ext__shared_ptrT_StrikedTypePayoff_t", "ext::shared_ptr< StrikedTypePayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t = {"_p_ext__shared_ptrT_StrippedOptionletAdapter_t", "ext::shared_ptr< StrippedOptionletAdapter > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StrippedOptionletBase_t = {"_p_ext__shared_ptrT_StrippedOptionletBase_t", "ext::shared_ptr< StrippedOptionletBase > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_StulzEngine_t = {"_p_ext__shared_ptrT_StulzEngine_t", "ext::shared_ptr< StulzEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SuperSharePayoff_t = {"_p_ext__shared_ptrT_SuperSharePayoff_t", "ext::shared_ptr< SuperSharePayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwapIndex_t = {"_p_ext__shared_ptrT_SwapIndex_t", "ext::shared_ptr< SwapIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwapRateHelper_t = {"_p_ext__shared_ptrT_SwapRateHelper_t", "ext::shared_ptr< SwapRateHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwapSpreadIndex_t = {"_p_ext__shared_ptrT_SwapSpreadIndex_t", "ext::shared_ptr< SwapSpreadIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Swap_t = {"_p_ext__shared_ptrT_Swap_t", "ext::shared_ptr< Swap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionHelper_t = {"_p_ext__shared_ptrT_SwaptionHelper_t", "ext::shared_ptr< SwaptionHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionVolCube1_t = {"_p_ext__shared_ptrT_SwaptionVolCube1_t", "ext::shared_ptr< SwaptionVolCube1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionVolCube2_t = {"_p_ext__shared_ptrT_SwaptionVolCube2_t", "ext::shared_ptr< SwaptionVolCube2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t = {"_p_ext__shared_ptrT_SwaptionVolatilityCube_t", "ext::shared_ptr< SwaptionVolatilityCube > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t = {"_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t", "ext::shared_ptr< SwaptionVolatilityDiscrete > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t = {"_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t", "ext::shared_ptr< SwaptionVolatilityMatrix > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwaptionVolatilityStructure_t = {"_p_ext__shared_ptrT_SwaptionVolatilityStructure_t", "ext::shared_ptr< SwaptionVolatilityStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Swaption_t = {"_p_ext__shared_ptrT_Swaption_t", "ext::shared_ptr< Swaption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_SwingExercise_t = {"_p_ext__shared_ptrT_SwingExercise_t", "ext::shared_ptr< SwingExercise > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_THBFIX_t = {"_p_ext__shared_ptrT_THBFIX_t", "ext::shared_ptr< THBFIX > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TRLibor_t = {"_p_ext__shared_ptrT_TRLibor_t", "ext::shared_ptr< TRLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TermStructureConsistentModel_t = {"_p_ext__shared_ptrT_TermStructureConsistentModel_t", "ext::shared_ptr< TermStructureConsistentModel > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TermStructure_t = {"_p_ext__shared_ptrT_TermStructure_t", "ext::shared_ptr< TermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Tibor_t = {"_p_ext__shared_ptrT_Tibor_t", "ext::shared_ptr< Tibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t = {"_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t", "ext::shared_ptr< TreeCallableFixedRateBondEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TreeCapFloorEngine_t = {"_p_ext__shared_ptrT_TreeCapFloorEngine_t", "ext::shared_ptr< TreeCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TreeSwaptionEngine_t = {"_p_ext__shared_ptrT_TreeSwaptionEngine_t", "ext::shared_ptr< TreeSwaptionEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TripleBandLinearOp_t = {"_p_ext__shared_ptrT_TripleBandLinearOp_t", "ext::shared_ptr< TripleBandLinearOp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_TypePayoff_t = {"_p_ext__shared_ptrT_TypePayoff_t", "ext::shared_ptr< TypePayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_UKRPI_t = {"_p_ext__shared_ptrT_UKRPI_t", "ext::shared_ptr< UKRPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_USCPI_t = {"_p_ext__shared_ptrT_USCPI_t", "ext::shared_ptr< USCPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_USDLiborON_t = {"_p_ext__shared_ptrT_USDLiborON_t", "ext::shared_ptr< USDLiborON > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_USDLibor_t = {"_p_ext__shared_ptrT_USDLibor_t", "ext::shared_ptr< USDLibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Uniform1dMesher_t = {"_p_ext__shared_ptrT_Uniform1dMesher_t", "ext::shared_ptr< Uniform1dMesher > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_UpfrontCdsHelper_t = {"_p_ext__shared_ptrT_UpfrontCdsHelper_t", "ext::shared_ptr< UpfrontCdsHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t = {"_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t", "ext::shared_ptr< UsdLiborSwapIsdaFixAm > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t = {"_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t", "ext::shared_ptr< UsdLiborSwapIsdaFixPm > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VanillaForwardPayoff_t = {"_p_ext__shared_ptrT_VanillaForwardPayoff_t", "ext::shared_ptr< VanillaForwardPayoff > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VanillaOption_t = {"_p_ext__shared_ptrT_VanillaOption_t", "ext::shared_ptr< VanillaOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VanillaSwap_t = {"_p_ext__shared_ptrT_VanillaSwap_t", "ext::shared_ptr< VanillaSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VanillaSwingOption_t = {"_p_ext__shared_ptrT_VanillaSwingOption_t", "ext::shared_ptr< VanillaSwingOption > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t = {"_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t", "ext::shared_ptr< VannaVolgaBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t = {"_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t", "ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t = {"_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t", "ext::shared_ptr< VannaVolgaDoubleBarrierEngine< WulinYongDoubleBarrierEngine > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VarianceGammaEngine_t = {"_p_ext__shared_ptrT_VarianceGammaEngine_t", "ext::shared_ptr< VarianceGammaEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VarianceGammaProcess_t = {"_p_ext__shared_ptrT_VarianceGammaProcess_t", "ext::shared_ptr< VarianceGammaProcess > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Vasicek_t = {"_p_ext__shared_ptrT_Vasicek_t", "ext::shared_ptr< Vasicek > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_VolatilityTermStructure_t = {"_p_ext__shared_ptrT_VolatilityTermStructure_t", "ext::shared_ptr< VolatilityTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Wibor_t = {"_p_ext__shared_ptrT_Wibor_t", "ext::shared_ptr< Wibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t = {"_p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t", "ext::shared_ptr< WulinYongDoubleBarrierEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYEUHICPXT_t = {"_p_ext__shared_ptrT_YYEUHICPXT_t", "ext::shared_ptr< YYEUHICPXT > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYEUHICP_t = {"_p_ext__shared_ptrT_YYEUHICP_t", "ext::shared_ptr< YYEUHICP > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYEUHICPr_t = {"_p_ext__shared_ptrT_YYEUHICPr_t", "ext::shared_ptr< YYEUHICPr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYFRHICP_t = {"_p_ext__shared_ptrT_YYFRHICP_t", "ext::shared_ptr< YYFRHICP > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYFRHICPr_t = {"_p_ext__shared_ptrT_YYFRHICPr_t", "ext::shared_ptr< YYFRHICPr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYUKRPI_t = {"_p_ext__shared_ptrT_YYUKRPI_t", "ext::shared_ptr< YYUKRPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYUKRPIr_t = {"_p_ext__shared_ptrT_YYUKRPIr_t", "ext::shared_ptr< YYUKRPIr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYUSCPI_t = {"_p_ext__shared_ptrT_YYUSCPI_t", "ext::shared_ptr< YYUSCPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYUSCPIr_t = {"_p_ext__shared_ptrT_YYUSCPIr_t", "ext::shared_ptr< YYUSCPIr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYZACPI_t = {"_p_ext__shared_ptrT_YYZACPI_t", "ext::shared_ptr< YYZACPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YYZACPIr_t = {"_p_ext__shared_ptrT_YYZACPIr_t", "ext::shared_ptr< YYZACPIr > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t = {"_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t", "ext::shared_ptr< YearOnYearInflationSwapHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YearOnYearInflationSwap_t = {"_p_ext__shared_ptrT_YearOnYearInflationSwap_t", "ext::shared_ptr< YearOnYearInflationSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YieldTermStructure_t = {"_p_ext__shared_ptrT_YieldTermStructure_t", "ext::shared_ptr< YieldTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t = {"_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t", "ext::shared_ptr< YoYCapFloorTermPriceSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t = {"_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t", "ext::shared_ptr< YoYInflationBachelierCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t = {"_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t", "ext::shared_ptr< YoYInflationBlackCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t = {"_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t", "ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationCapFloor_t = {"_p_ext__shared_ptrT_YoYInflationCapFloor_t", "ext::shared_ptr< YoYInflationCapFloor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationCap_t = {"_p_ext__shared_ptrT_YoYInflationCap_t", "ext::shared_ptr< YoYInflationCap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationCollar_t = {"_p_ext__shared_ptrT_YoYInflationCollar_t", "ext::shared_ptr< YoYInflationCollar > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationFloor_t = {"_p_ext__shared_ptrT_YoYInflationFloor_t", "ext::shared_ptr< YoYInflationFloor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationIndex_t = {"_p_ext__shared_ptrT_YoYInflationIndex_t", "ext::shared_ptr< YoYInflationIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationTermStructure_t = {"_p_ext__shared_ptrT_YoYInflationTermStructure_t", "ext::shared_ptr< YoYInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t = {"_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t", "ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYOptionletHelper_t = {"_p_ext__shared_ptrT_YoYOptionletHelper_t", "ext::shared_ptr< YoYOptionletHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYOptionletStripper_t = {"_p_ext__shared_ptrT_YoYOptionletStripper_t", "ext::shared_ptr< YoYOptionletStripper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t = {"_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t", "ext::shared_ptr< YoYOptionletVolatilitySurface > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZACPI_t = {"_p_ext__shared_ptrT_ZACPI_t", "ext::shared_ptr< ZACPI > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t = {"_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t", "ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t = {"_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t", "ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t = {"_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t", "ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t = {"_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t", "ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t = {"_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t", "ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t = {"_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t", "ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t = {"_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t", "ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t = {"_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t", "ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZeroCouponBond_t = {"_p_ext__shared_ptrT_ZeroCouponBond_t", "ext::shared_ptr< ZeroCouponBond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t = {"_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t", "ext::shared_ptr< ZeroCouponInflationSwapHelper > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZeroCouponInflationSwap_t = {"_p_ext__shared_ptrT_ZeroCouponInflationSwap_t", "ext::shared_ptr< ZeroCouponInflationSwap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZeroInflationIndex_t = {"_p_ext__shared_ptrT_ZeroInflationIndex_t", "ext::shared_ptr< ZeroInflationIndex > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZeroInflationTermStructure_t = {"_p_ext__shared_ptrT_ZeroInflationTermStructure_t", "ext::shared_ptr< ZeroInflationTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t = {"_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t", "ext::shared_ptr< ZeroSpreadedTermStructure > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__shared_ptrT_Zibor_t = {"_p_ext__shared_ptrT_Zibor_t", "ext::shared_ptr< Zibor > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__tupleT_double_double_bool_t = {"_p_ext__tupleT_double_double_bool_t", "std::vector< ext::tuple< double,double,bool > >::value_type *|ext::tuple< double,double,bool > *|ext::tuple< Real,Real,bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ext__tupleT_double_double_double_t = {"_p_ext__tupleT_double_double_double_t", "ext::tuple< Real,Real,Real > *|ext::tuple< double,double,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_first_type = {"_p_first_type", "first_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *|Hour *|Year *|Minute *|Day *|Integer *|Second *|Millisecond *|Microsecond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "long *|BigInteger *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sample_type = {"_p_sample_type", "sample_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_second_type = {"_p_second_type", "second_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "Size *|size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Date_t = {"_p_std__allocatorT_Date_t", "std::allocator< Date > *|std::vector< Date >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_HandleT_Quote_t_t = {"_p_std__allocatorT_HandleT_Quote_t_t", "std::allocator< Handle< Quote > > *|std::vector< Handle< Quote > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_InterestRate_t = {"_p_std__allocatorT_InterestRate_t", "std::allocator< InterestRate > *|std::vector< InterestRate >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_IntervalPrice_t = {"_p_std__allocatorT_IntervalPrice_t", "std::vector< IntervalPrice >::allocator_type *|std::allocator< IntervalPrice > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Period_t = {"_p_std__allocatorT_Period_t", "std::allocator< Period > *|std::vector< Period >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_RelinkableHandleT_Quote_t_t = {"_p_std__allocatorT_RelinkableHandleT_Quote_t_t", "std::allocator< RelinkableHandle< Quote > > *|std::vector< RelinkableHandle< Quote > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_bool_t = {"_p_std__allocatorT_bool_t", "std::vector< bool >::allocator_type *|std::allocator< bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t = {"_p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t", "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::allocator_type *|std::allocator< ext::shared_ptr< BlackCalibrationHelper > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t = {"_p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t", "std::vector< ext::shared_ptr< BondHelper > >::allocator_type *|std::allocator< ext::shared_ptr< BondHelper > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t = {"_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t", "std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *|std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t = {"_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t", "std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *|std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t = {"_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t", "std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *|std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t = {"_p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t", "std::allocator< ext::shared_ptr< CalibrationHelper > > *|std::vector< ext::shared_ptr< CalibrationHelper > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_Callability_t_t = {"_p_std__allocatorT_ext__shared_ptrT_Callability_t_t", "std::allocator< ext::shared_ptr< Callability > > *|std::vector< ext::shared_ptr< Callability > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t = {"_p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t", "std::allocator< ext::shared_ptr< CashFlow > > *|std::vector< ext::shared_ptr< CashFlow > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t = {"_p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t", "std::vector< ext::shared_ptr< CmsCouponPricer > >::allocator_type *|std::allocator< ext::shared_ptr< CmsCouponPricer > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t = {"_p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t", "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::allocator_type *|std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_Dividend_t_t = {"_p_std__allocatorT_ext__shared_ptrT_Dividend_t_t", "std::allocator< ext::shared_ptr< Dividend > > *|std::vector< ext::shared_ptr< Dividend > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t = {"_p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t", "std::vector< ext::shared_ptr< Fdm1dMesher > >::allocator_type *|std::allocator< ext::shared_ptr< Fdm1dMesher > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t = {"_p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t", "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::allocator_type *|std::allocator< ext::shared_ptr< FdmBoundaryCondition > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_Instrument_t_t = {"_p_std__allocatorT_ext__shared_ptrT_Instrument_t_t", "std::vector< ext::shared_ptr< Instrument > >::allocator_type *|std::allocator< ext::shared_ptr< Instrument > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_Quote_t_t = {"_p_std__allocatorT_ext__shared_ptrT_Quote_t_t", "std::allocator< ext::shared_ptr< Quote > > *|std::vector< ext::shared_ptr< Quote > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t = {"_p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t", "std::vector< ext::shared_ptr< RateHelper > >::allocator_type *|std::allocator< ext::shared_ptr< RateHelper > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t = {"_p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t", "std::allocator< ext::shared_ptr< SmileSection > > *|std::vector< ext::shared_ptr< SmileSection > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t = {"_p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t", "std::allocator< ext::shared_ptr< StepCondition< Array > > > *|std::vector< ext::shared_ptr< StepCondition< Array > > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t = {"_p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t", "std::vector< ext::shared_ptr< StochasticProcess1D > >::allocator_type *|std::allocator< ext::shared_ptr< StochasticProcess1D > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t = {"_p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t", "std::vector< ext::shared_ptr< StochasticProcess > >::allocator_type *|std::allocator< ext::shared_ptr< StochasticProcess > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t = {"_p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t", "std::allocator< ext::shared_ptr< SwapIndex > > *|std::vector< ext::shared_ptr< SwapIndex > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t = {"_p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t", "std::allocator< ext::tuple< Real,Real,bool > > *|std::allocator< ext::tuple< double,double,bool > > *|std::vector< ext::tuple< double,double,bool > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_Date_double_t_t = {"_p_std__allocatorT_std__pairT_Date_double_t_t", "std::allocator< std::pair< Date,double > > *|std::vector< std::pair< Date,double > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_double_const_Date_t_t = {"_p_std__allocatorT_std__pairT_double_const_Date_t_t", "std::allocator< std::pair< double const,Date > > *|std::map< double,Date >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_double_double_t_t = {"_p_std__allocatorT_std__pairT_double_double_t_t", "std::allocator< std::pair< double,double > > *|std::vector< std::pair< double,double > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t = {"_p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t", "std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *|std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t = {"_p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t", "std::vector< std::vector< Handle< Quote > > >::allocator_type *|std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t = {"_p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t", "std::vector< std::vector< RelinkableHandle< Quote > > >::allocator_type *|std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t = {"_p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t", "std::vector< std::vector< ext::shared_ptr< Quote > > >::allocator_type *|std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_int_t = {"_p_std__allocatorT_unsigned_int_t", "std::vector< unsigned int >::allocator_type *|std::allocator< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_double_t = {"_p_std__lessT_double_t", "std::less< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t = {"_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t", "std::map< double,Date > *|std::map< Time,Date > *|std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_Date_double_t = {"_p_std__pairT_Date_double_t", "std::pair< Date,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_double_double_t = {"_p_std__pairT_double_double_t", "std::pair< double,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t = {"_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t", "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_size_t_size_t_t = {"_p_std__pairT_size_t_size_t_t", "std::pair< size_t,size_t > *|std::pair< Size,Size > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t", "std::pair< std::vector< Date,std::allocator< Date > >,std::vector< double,std::allocator< double > > > *|std::pair< std::vector< Date,std::allocator< Date > >,std::vector< Rate,std::allocator< Rate > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t", "std::pair< std::vector< double >,std::vector< double > > *|std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Date_std__allocatorT_Date_t_t = {"_p_std__vectorT_Date_std__allocatorT_Date_t_t", "std::vector< Date > *|std::vector< Date,std::allocator< Date > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t = {"_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t", "std::vector< Handle< Quote > > *|std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t = {"_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t", "std::vector< InterestRate > *|std::vector< InterestRate,std::allocator< InterestRate > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t = {"_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t", "std::vector< IntervalPrice > *|std::vector< IntervalPrice,std::allocator< IntervalPrice > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Period_std__allocatorT_Period_t_t = {"_p_std__vectorT_Period_std__allocatorT_Period_t_t", "std::vector< Period > *|std::vector< Period,std::allocator< Period > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t = {"_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t", "std::vector< RelinkableHandle< Quote > > *|std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t = {"_p_std__vectorT_bool_std__allocatorT_bool_t_t", "std::vector< bool,std::allocator< bool > > *|std::vector< bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t", "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *|std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t", "std::vector< ext::shared_ptr< BondHelper > > *|std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t", "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *|std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t", "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *|std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t", "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *|std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t", "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *|std::vector< ext::shared_ptr< CalibrationHelper > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t", "std::vector< ext::shared_ptr< Callability > > *|std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t", "std::vector< ext::shared_ptr< CashFlow > > *|std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *|Leg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t", "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *|std::vector< ext::shared_ptr< CmsCouponPricer > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t", "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *|std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t", "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *|std::vector< ext::shared_ptr< Dividend > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t", "std::vector< ext::shared_ptr< Fdm1dMesher > > *|std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t", "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *|std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *|FdmBoundaryConditionSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t", "std::vector< ext::shared_ptr< Instrument > > *|std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t", "std::vector< ext::shared_ptr< Quote > > *|std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t", "std::vector< ext::shared_ptr< RateHelper > > *|std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t", "std::vector< ext::shared_ptr< SmileSection > > *|std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t", "std::vector< ext::shared_ptr< StepCondition< Array > > > *|std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t", "std::vector< ext::shared_ptr< StochasticProcess1D > > *|std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t", "std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *|std::vector< ext::shared_ptr< StochasticProcess > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t = {"_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t", "std::vector< ext::shared_ptr< SwapIndex > > *|std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t = {"_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t", "std::vector< ext::tuple< double,double,bool > > *|std::vector< ext::tuple< Real,Real,bool > > *|std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *|std::vector< ext::tuple< double,double,bool >,std::allocator< ext::tuple< double,double,bool > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t = {"_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t", "std::vector< std::pair< Date,double > > *|std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t = {"_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t", "std::vector< std::pair< double,double > > *|std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__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 = {"_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", "AndreasenHugeVolatilityInterpl::CalibrationSet *|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< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_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 = {"_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", "std::vector< std::vector< Handle< Quote > > > *|std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *|std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__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 = {"_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", "std::vector< std::vector< RelinkableHandle< Quote > > > *|std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *|std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t = {"_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t", "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *|std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_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 = {"_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", "std::vector< std::vector< ext::shared_ptr< Quote > > > *|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< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t = {"_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t", "std::vector< unsigned int,std::allocator< unsigned int > > *|std::vector< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|Natural *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "BigNatural *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ASX,
  &_swigt__p_AUCPI,
  &_swigt__p_AUDLibor,
  &_swigt__p_AdaptiveRungeKuttaT_double_t,
  &_swigt__p_AmericanExercise,
  &_swigt__p_AmortizingFixedRateBond,
  &_swigt__p_AmortizingFloatingRateBond,
  &_swigt__p_AmortizingPayment,
  &_swigt__p_AnalyticBSMHullWhiteEngine,
  &_swigt__p_AnalyticBarrierEngine,
  &_swigt__p_AnalyticBinaryBarrierEngine,
  &_swigt__p_AnalyticCEVEngine,
  &_swigt__p_AnalyticCapFloorEngine,
  &_swigt__p_AnalyticContinuousGeometricAveragePriceAsianEngine,
  &_swigt__p_AnalyticDigitalAmericanEngine,
  &_swigt__p_AnalyticDigitalAmericanKOEngine,
  &_swigt__p_AnalyticDiscreteGeometricAveragePriceAsianEngine,
  &_swigt__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine,
  &_swigt__p_AnalyticDividendEuropeanEngine,
  &_swigt__p_AnalyticDoubleBarrierBinaryEngine,
  &_swigt__p_AnalyticDoubleBarrierEngine,
  &_swigt__p_AnalyticEuropeanEngine,
  &_swigt__p_AnalyticGJRGARCHEngine,
  &_swigt__p_AnalyticHaganPricer,
  &_swigt__p_AnalyticHestonEngine,
  &_swigt__p_AnalyticHestonEngine__Integration,
  &_swigt__p_AnalyticPTDHestonEngine,
  &_swigt__p_AndreasenHugeLocalVolAdapter,
  &_swigt__p_AndreasenHugeVolatilityAdapter,
  &_swigt__p_AndreasenHugeVolatilityInterpl,
  &_swigt__p_Aonia,
  &_swigt__p_Array,
  &_swigt__p_AssetOrNothingPayoff,
  &_swigt__p_AssetSwap,
  &_swigt__p_Average,
  &_swigt__p_AverageBasketPayoff,
  &_swigt__p_BFGS,
  &_swigt__p_BSMRNDCalculator,
  &_swigt__p_BachelierCapFloorEngine,
  &_swigt__p_BachelierSwaptionEngine,
  &_swigt__p_BackwardFlat,
  &_swigt__p_BaroneAdesiWhaleyApproximationEngine,
  &_swigt__p_Barrier,
  &_swigt__p_BarrierOption,
  &_swigt__p_BasketOption,
  &_swigt__p_BasketPayoff,
  &_swigt__p_BatesEngine,
  &_swigt__p_BatesModel,
  &_swigt__p_BatesProcess,
  &_swigt__p_Bbsw,
  &_swigt__p_Bbsw1M,
  &_swigt__p_Bbsw2M,
  &_swigt__p_Bbsw3M,
  &_swigt__p_Bbsw4M,
  &_swigt__p_Bbsw5M,
  &_swigt__p_Bbsw6M,
  &_swigt__p_BermudanExercise,
  &_swigt__p_BiCGstab,
  &_swigt__p_Bibor,
  &_swigt__p_Bibor1M,
  &_swigt__p_Bibor1Y,
  &_swigt__p_Bibor2M,
  &_swigt__p_Bibor3M,
  &_swigt__p_Bibor6M,
  &_swigt__p_Bibor9M,
  &_swigt__p_BiborSW,
  &_swigt__p_Bicubic,
  &_swigt__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t,
  &_swigt__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t,
  &_swigt__p_BinomialConvertibleEngineT_CoxRossRubinstein_t,
  &_swigt__p_BinomialConvertibleEngineT_JarrowRudd_t,
  &_swigt__p_BinomialConvertibleEngineT_Joshi4_t,
  &_swigt__p_BinomialConvertibleEngineT_LeisenReimer_t,
  &_swigt__p_BinomialConvertibleEngineT_Tian_t,
  &_swigt__p_BinomialConvertibleEngineT_Trigeorgis_t,
  &_swigt__p_BinomialDistribution,
  &_swigt__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t,
  &_swigt__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t,
  &_swigt__p_BinomialVanillaEngineT_CoxRossRubinstein_t,
  &_swigt__p_BinomialVanillaEngineT_JarrowRudd_t,
  &_swigt__p_BinomialVanillaEngineT_Joshi4_t,
  &_swigt__p_BinomialVanillaEngineT_LeisenReimer_t,
  &_swigt__p_BinomialVanillaEngineT_Tian_t,
  &_swigt__p_BinomialVanillaEngineT_Trigeorgis_t,
  &_swigt__p_Bisection,
  &_swigt__p_BivariateCumulativeNormalDistribution,
  &_swigt__p_BivariateCumulativeNormalDistributionDr78,
  &_swigt__p_BivariateCumulativeNormalDistributionWe04DP,
  &_swigt__p_BjerksundStenslandApproximationEngine,
  &_swigt__p_Bkbm,
  &_swigt__p_Bkbm1M,
  &_swigt__p_Bkbm2M,
  &_swigt__p_Bkbm3M,
  &_swigt__p_Bkbm4M,
  &_swigt__p_Bkbm5M,
  &_swigt__p_Bkbm6M,
  &_swigt__p_BlackCalculator,
  &_swigt__p_BlackCalibrationHelper,
  &_swigt__p_BlackCallableFixedRateBondEngine,
  &_swigt__p_BlackCapFloorEngine,
  &_swigt__p_BlackCdsOptionEngine,
  &_swigt__p_BlackConstantVol,
  &_swigt__p_BlackDeltaCalculator,
  &_swigt__p_BlackIborCouponPricer,
  &_swigt__p_BlackKarasinski,
  &_swigt__p_BlackProcess,
  &_swigt__p_BlackScholesMertonProcess,
  &_swigt__p_BlackScholesProcess,
  &_swigt__p_BlackSwaptionEngine,
  &_swigt__p_BlackVarianceCurve,
  &_swigt__p_BlackVarianceSurface,
  &_swigt__p_BlackVolTermStructure,
  &_swigt__p_Bond,
  &_swigt__p_BondFunctions,
  &_swigt__p_BondHelper,
  &_swigt__p_BootstrapHelperT_YoYInflationTermStructure_t,
  &_swigt__p_BootstrapHelperT_YoYOptionletVolatilitySurface_t,
  &_swigt__p_BootstrapHelperT_ZeroInflationTermStructure_t,
  &_swigt__p_BoundaryConstraint,
  &_swigt__p_BoxMullerGaussianRngT_KnuthUniformRng_t,
  &_swigt__p_BoxMullerGaussianRngT_LecuyerUniformRng_t,
  &_swigt__p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t,
  &_swigt__p_Brent,
  &_swigt__p_BrownianBridge,
  &_swigt__p_BrownianGeneratorFactory,
  &_swigt__p_CADLibor,
  &_swigt__p_CADLiborON,
  &_swigt__p_CEVRNDCalculator,
  &_swigt__p_CHFLibor,
  &_swigt__p_CLGaussianRngT_KnuthUniformRng_t,
  &_swigt__p_CLGaussianRngT_LecuyerUniformRng_t,
  &_swigt__p_CLGaussianRngT_MersenneTwisterUniformRng_t,
  &_swigt__p_COSHestonEngine,
  &_swigt__p_CPI,
  &_swigt__p_CPIBond,
  &_swigt__p_CPICoupon,
  &_swigt__p_CPISwap,
  &_swigt__p_Calendar,
  &_swigt__p_CalibratedModel,
  &_swigt__p_CalibrationHelper,
  &_swigt__p_CalibrationSet,
  &_swigt__p_Callability,
  &_swigt__p_CallabilityPrice,
  &_swigt__p_CallableBond,
  &_swigt__p_CallableFixedRateBond,
  &_swigt__p_CallableZeroCouponBond,
  &_swigt__p_Cap,
  &_swigt__p_CapFloor,
  &_swigt__p_CapFloorTermVolCurve,
  &_swigt__p_CapFloorTermVolSurface,
  &_swigt__p_CapFloorTermVolatilityStructure,
  &_swigt__p_CapHelper,
  &_swigt__p_CappedFlooredCmsCoupon,
  &_swigt__p_CappedFlooredCmsSpreadCoupon,
  &_swigt__p_CappedFlooredCoupon,
  &_swigt__p_CappedFlooredIborCoupon,
  &_swigt__p_CashFlow,
  &_swigt__p_CashFlows,
  &_swigt__p_CashOrNothingPayoff,
  &_swigt__p_Cdor,
  &_swigt__p_CdsOption,
  &_swigt__p_CeilingTruncation,
  &_swigt__p_ChfLiborSwapIsdaFix,
  &_swigt__p_Claim,
  &_swigt__p_ClosestRounding,
  &_swigt__p_CmsCoupon,
  &_swigt__p_CmsCouponPricer,
  &_swigt__p_CmsMarket,
  &_swigt__p_CmsMarketCalibration,
  &_swigt__p_CmsRateBond,
  &_swigt__p_CmsSpreadCoupon,
  &_swigt__p_CmsSpreadCouponPricer,
  &_swigt__p_Collar,
  &_swigt__p_CompositeConstraint,
  &_swigt__p_CompositeInstrument,
  &_swigt__p_CompositeQuoteT_BinaryFunction_t,
  &_swigt__p_Concentrating1dMesher,
  &_swigt__p_Conditions,
  &_swigt__p_ConjugateGradient,
  &_swigt__p_ConstantEstimator,
  &_swigt__p_ConstantOptionletVolatility,
  &_swigt__p_ConstantParameter,
  &_swigt__p_ConstantSwaptionVolatility,
  &_swigt__p_ConstantYoYOptionletVolatility,
  &_swigt__p_Constraint,
  &_swigt__p_ContinuousArithmeticAsianLevyEngine,
  &_swigt__p_ContinuousAveragingAsianOption,
  &_swigt__p_ConvertibleFixedCouponBond,
  &_swigt__p_ConvertibleFloatingRateBond,
  &_swigt__p_ConvertibleZeroCouponBond,
  &_swigt__p_ConvexMonotone,
  &_swigt__p_Coupon,
  &_swigt__p_CoxIngersollRoss,
  &_swigt__p_CraigSneydScheme,
  &_swigt__p_CrankNicolsonScheme,
  &_swigt__p_CreditDefaultSwap,
  &_swigt__p_Cubic,
  &_swigt__p_CubicBSplinesFitting,
  &_swigt__p_CumulativeBinomialDistribution,
  &_swigt__p_CumulativeChiSquareDistribution,
  &_swigt__p_CumulativeGammaDistribution,
  &_swigt__p_CumulativeNormalDistribution,
  &_swigt__p_CumulativePoissonDistribution,
  &_swigt__p_CumulativeStudentDistribution,
  &_swigt__p_Currency,
  &_swigt__p_CustomRegion,
  &_swigt__p_DKKLibor,
  &_swigt__p_DMinus,
  &_swigt__p_DPlus,
  &_swigt__p_DPlusDMinus,
  &_swigt__p_DZero,
  &_swigt__p_DailyTenorLibor,
  &_swigt__p_Date,
  &_swigt__p_DateGeneration,
  &_swigt__p_DateParser,
  &_swigt__p_DatedOISRateHelper,
  &_swigt__p_DayCounter,
  &_swigt__p_DefaultBoundaryCondition,
  &_swigt__p_DefaultDensity,
  &_swigt__p_DefaultLexicographicalView,
  &_swigt__p_DefaultLexicographicalViewColumn,
  &_swigt__p_DefaultLogCubic,
  &_swigt__p_DefaultProbabilityHelper,
  &_swigt__p_DefaultProbabilityTermStructure,
  &_swigt__p_DeltaVolQuote,
  &_swigt__p_DepositRateHelper,
  &_swigt__p_DerivedQuoteT_UnaryFunction_t,
  &_swigt__p_DifferentialEvolution,
  &_swigt__p_DirichletBC,
  &_swigt__p_Discount,
  &_swigt__p_DiscountingBondEngine,
  &_swigt__p_DiscountingSwapEngine,
  &_swigt__p_DiscreteAveragingAsianOption,
  &_swigt__p_DisposableT_Array_t,
  &_swigt__p_Dividend,
  &_swigt__p_DividendBarrierOption,
  &_swigt__p_DividendVanillaOption,
  &_swigt__p_DoubleBarrier,
  &_swigt__p_DoubleBarrierOption,
  &_swigt__p_DouglasScheme,
  &_swigt__p_DownRounding,
  &_swigt__p_Duration,
  &_swigt__p_EUHICP,
  &_swigt__p_EUHICPXT,
  &_swigt__p_EURLibor,
  &_swigt__p_EURLibor10M,
  &_swigt__p_EURLibor11M,
  &_swigt__p_EURLibor1M,
  &_swigt__p_EURLibor1Y,
  &_swigt__p_EURLibor2M,
  &_swigt__p_EURLibor2W,
  &_swigt__p_EURLibor3M,
  &_swigt__p_EURLibor4M,
  &_swigt__p_EURLibor5M,
  &_swigt__p_EURLibor6M,
  &_swigt__p_EURLibor7M,
  &_swigt__p_EURLibor8M,
  &_swigt__p_EURLibor9M,
  &_swigt__p_EURLiborSW,
  &_swigt__p_EndCriteria,
  &_swigt__p_EndCriteria__Type,
  &_swigt__p_Eonia,
  &_swigt__p_EurLiborSwapIfrFix,
  &_swigt__p_EurLiborSwapIsdaFixA,
  &_swigt__p_EurLiborSwapIsdaFixB,
  &_swigt__p_Euribor,
  &_swigt__p_Euribor10M,
  &_swigt__p_Euribor11M,
  &_swigt__p_Euribor1M,
  &_swigt__p_Euribor1Y,
  &_swigt__p_Euribor2M,
  &_swigt__p_Euribor2W,
  &_swigt__p_Euribor365,
  &_swigt__p_Euribor365_10M,
  &_swigt__p_Euribor365_11M,
  &_swigt__p_Euribor365_1M,
  &_swigt__p_Euribor365_1Y,
  &_swigt__p_Euribor365_2M,
  &_swigt__p_Euribor365_2W,
  &_swigt__p_Euribor365_3M,
  &_swigt__p_Euribor365_3W,
  &_swigt__p_Euribor365_4M,
  &_swigt__p_Euribor365_5M,
  &_swigt__p_Euribor365_6M,
  &_swigt__p_Euribor365_7M,
  &_swigt__p_Euribor365_8M,
  &_swigt__p_Euribor365_9M,
  &_swigt__p_Euribor365_SW,
  &_swigt__p_Euribor3M,
  &_swigt__p_Euribor3W,
  &_swigt__p_Euribor4M,
  &_swigt__p_Euribor5M,
  &_swigt__p_Euribor6M,
  &_swigt__p_Euribor7M,
  &_swigt__p_Euribor8M,
  &_swigt__p_Euribor9M,
  &_swigt__p_EuriborSW,
  &_swigt__p_EuriborSwapIfrFix,
  &_swigt__p_EuriborSwapIsdaFixA,
  &_swigt__p_EuriborSwapIsdaFixB,
  &_swigt__p_EuropeanExercise,
  &_swigt__p_EuropeanOption,
  &_swigt__p_EverestOption,
  &_swigt__p_ExchangeRate,
  &_swigt__p_ExchangeRateManager,
  &_swigt__p_Exercise,
  &_swigt__p_ExplicitEulerScheme,
  &_swigt__p_ExponentialFittingHestonEngine,
  &_swigt__p_ExponentialJump1dMesher,
  &_swigt__p_ExponentialSplinesFitting,
  &_swigt__p_ExtOUWithJumpsProcess,
  &_swigt__p_ExtendedCoxIngersollRoss,
  &_swigt__p_ExtendedOrnsteinUhlenbeckProcess,
  &_swigt__p_FDAmericanEngineT_CrankNicolson_t,
  &_swigt__p_FDBermudanEngineT_CrankNicolson_t,
  &_swigt__p_FDDividendAmericanEngineT_CrankNicolson_t,
  &_swigt__p_FDDividendEuropeanEngineT_CrankNicolson_t,
  &_swigt__p_FDEuropeanEngineT_CrankNicolson_t,
  &_swigt__p_FDShoutEngineT_CrankNicolson_t,
  &_swigt__p_FFTVarianceGammaEngine,
  &_swigt__p_FRHICP,
  &_swigt__p_FaceValueAccrualClaim,
  &_swigt__p_FaceValueClaim,
  &_swigt__p_FalsePosition,
  &_swigt__p_Fd2dBlackScholesVanillaEngine,
  &_swigt__p_FdBatesVanillaEngine,
  &_swigt__p_FdBlackScholesAsianEngine,
  &_swigt__p_FdBlackScholesBarrierEngine,
  &_swigt__p_FdBlackScholesRebateEngine,
  &_swigt__p_FdBlackScholesVanillaEngine,
  &_swigt__p_FdCEVVanillaEngine,
  &_swigt__p_FdG2SwaptionEngine,
  &_swigt__p_FdHestonBarrierEngine,
  &_swigt__p_FdHestonDoubleBarrierEngine,
  &_swigt__p_FdHestonRebateEngine,
  &_swigt__p_FdHestonVanillaEngine,
  &_swigt__p_FdHullWhiteSwaptionEngine,
  &_swigt__p_FdOrnsteinUhlenbeckVanillaEngine,
  &_swigt__p_FdSabrVanillaEngine,
  &_swigt__p_FdSimpleBSSwingEngine,
  &_swigt__p_FdSimpleExtOUJumpSwingEngine,
  &_swigt__p_Fdm1DimSolver,
  &_swigt__p_Fdm1dMesher,
  &_swigt__p_Fdm2DimSolver,
  &_swigt__p_Fdm2dBlackScholesOp,
  &_swigt__p_Fdm2dBlackScholesSolver,
  &_swigt__p_Fdm3DimSolver,
  &_swigt__p_FdmAffineModelSwapInnerValueT_G2_t,
  &_swigt__p_FdmAffineModelSwapInnerValueT_HullWhite_t,
  &_swigt__p_FdmAmericanStepCondition,
  &_swigt__p_FdmArithmeticAverageCondition,
  &_swigt__p_FdmBackwardSolver,
  &_swigt__p_FdmBatesOp,
  &_swigt__p_FdmBermudanStepCondition,
  &_swigt__p_FdmBlackScholesFwdOp,
  &_swigt__p_FdmBlackScholesMesher,
  &_swigt__p_FdmBlackScholesOp,
  &_swigt__p_FdmBoundaryCondition,
  &_swigt__p_FdmCEV1dMesher,
  &_swigt__p_FdmCEVOp,
  &_swigt__p_FdmCellAveragingInnerValue,
  &_swigt__p_FdmDirichletBoundary,
  &_swigt__p_FdmDiscountDirichletBoundary,
  &_swigt__p_FdmDividendHandler,
  &_swigt__p_FdmDupire1dOp,
  &_swigt__p_FdmG2Op,
  &_swigt__p_FdmG2Solver,
  &_swigt__p_FdmHestonFwdOp,
  &_swigt__p_FdmHestonGreensFct,
  &_swigt__p_FdmHestonHullWhiteOp,
  &_swigt__p_FdmHestonHullWhiteSolver,
  &_swigt__p_FdmHestonLocalVolatilityVarianceMesher,
  &_swigt__p_FdmHestonOp,
  &_swigt__p_FdmHestonSolver,
  &_swigt__p_FdmHestonVarianceMesher,
  &_swigt__p_FdmHullWhiteOp,
  &_swigt__p_FdmHullWhiteSolver,
  &_swigt__p_FdmIndicesOnBoundary,
  &_swigt__p_FdmInnerValueCalculator,
  &_swigt__p_FdmInnerValueCalculatorProxy,
  &_swigt__p_FdmLinearOp,
  &_swigt__p_FdmLinearOpComposite,
  &_swigt__p_FdmLinearOpCompositeProxy,
  &_swigt__p_FdmLinearOpIterator,
  &_swigt__p_FdmLinearOpLayout,
  &_swigt__p_FdmLocalVolFwdOp,
  &_swigt__p_FdmLogBasketInnerValue,
  &_swigt__p_FdmLogInnerValue,
  &_swigt__p_FdmMesher,
  &_swigt__p_FdmMesherComposite,
  &_swigt__p_FdmNdimSolverT_4_t,
  &_swigt__p_FdmNdimSolverT_5_t,
  &_swigt__p_FdmNdimSolverT_6_t,
  &_swigt__p_FdmOrnsteinUhlenbeckOp,
  &_swigt__p_FdmQuantoHelper,
  &_swigt__p_FdmSabrOp,
  &_swigt__p_FdmSchemeDesc,
  &_swigt__p_FdmSimpleProcess1dMesher,
  &_swigt__p_FdmSimpleStorageCondition,
  &_swigt__p_FdmSimpleSwingCondition,
  &_swigt__p_FdmSnapshotCondition,
  &_swigt__p_FdmSolverDesc,
  &_swigt__p_FdmSquareRootFwdOp,
  &_swigt__p_FdmStepConditionComposite,
  &_swigt__p_FdmStepConditionProxy,
  &_swigt__p_FdmTimeDepDirichletBoundary,
  &_swigt__p_FdmZabrOp,
  &_swigt__p_FdmZeroInnerValue,
  &_swigt__p_FedFunds,
  &_swigt__p_FirstDerivativeOp,
  &_swigt__p_FittedBondDiscountCurve,
  &_swigt__p_FittingMethod,
  &_swigt__p_FixedDividend,
  &_swigt__p_FixedRateBond,
  &_swigt__p_FixedRateBondForward,
  &_swigt__p_FixedRateBondHelper,
  &_swigt__p_FixedRateCoupon,
  &_swigt__p_FlatForward,
  &_swigt__p_FlatHazardRate,
  &_swigt__p_FlatSmileSection,
  &_swigt__p_FloatFloatSwap,
  &_swigt__p_FloatFloatSwaption,
  &_swigt__p_FloatingRateBond,
  &_swigt__p_FloatingRateCoupon,
  &_swigt__p_FloatingRateCouponPricer,
  &_swigt__p_Floor,
  &_swigt__p_FloorTruncation,
  &_swigt__p_Forward,
  &_swigt__p_ForwardEuropeanEngine,
  &_swigt__p_ForwardFlat,
  &_swigt__p_ForwardRate,
  &_swigt__p_ForwardRateAgreement,
  &_swigt__p_ForwardSpreadedTermStructure,
  &_swigt__p_ForwardVanillaOption,
  &_swigt__p_FraRateHelper,
  &_swigt__p_FractionalDividend,
  &_swigt__p_Futures,
  &_swigt__p_FuturesRateHelper,
  &_swigt__p_FxSwapRateHelper,
  &_swigt__p_G2,
  &_swigt__p_G2ForwardProcess,
  &_swigt__p_G2Process,
  &_swigt__p_G2SwaptionEngine,
  &_swigt__p_GBPLibor,
  &_swigt__p_GBPLiborON,
  &_swigt__p_GBSMRNDCalculator,
  &_swigt__p_GFunctionFactory,
  &_swigt__p_GJRGARCHModel,
  &_swigt__p_GJRGARCHProcess,
  &_swigt__p_GMRES,
  &_swigt__p_GammaFunction,
  &_swigt__p_GapPayoff,
  &_swigt__p_GarmanKlassSigma1,
  &_swigt__p_GarmanKlassSigma3,
  &_swigt__p_GarmanKlassSigma4,
  &_swigt__p_GarmanKlassSigma5,
  &_swigt__p_GarmanKlassSigma6,
  &_swigt__p_GarmanKohlagenProcess,
  &_swigt__p_GaussChebyshev2ndIntegration,
  &_swigt__p_GaussChebyshevIntegration,
  &_swigt__p_GaussGegenbauerIntegration,
  &_swigt__p_GaussHermiteIntegration,
  &_swigt__p_GaussHyperbolicIntegration,
  &_swigt__p_GaussJacobiIntegration,
  &_swigt__p_GaussKronrodAdaptive,
  &_swigt__p_GaussKronrodNonAdaptive,
  &_swigt__p_GaussLaguerreIntegration,
  &_swigt__p_GaussLegendreIntegration,
  &_swigt__p_GaussLobattoIntegral,
  &_swigt__p_Gaussian1dFloatFloatSwaptionEngine,
  &_swigt__p_Gaussian1dJamshidianSwaptionEngine,
  &_swigt__p_Gaussian1dModel,
  &_swigt__p_Gaussian1dNonstandardSwaptionEngine,
  &_swigt__p_Gaussian1dSwaptionEngine,
  &_swigt__p_GaussianLowDiscrepancySequenceGenerator,
  &_swigt__p_GaussianMultiPathGenerator,
  &_swigt__p_GaussianRandomGenerator,
  &_swigt__p_GaussianRandomSequenceGenerator,
  &_swigt__p_GaussianSimulatedAnnealing,
  &_swigt__p_GbpLiborSwapIsdaFix,
  &_swigt__p_GeneralizedBlackScholesProcess,
  &_swigt__p_GenericSequenceStatisticsT_IncrementalStatistics_t,
  &_swigt__p_GenericSequenceStatisticsT_RiskStatistics_t,
  &_swigt__p_GenericSequenceStatisticsT_Statistics_t,
  &_swigt__p_GeometricBrownianMotionProcess,
  &_swigt__p_GlobalLinearSimpleZeroCurve,
  &_swigt__p_Glued1dMesher,
  &_swigt__p_Gsr,
  &_swigt__p_GsrProcess,
  &_swigt__p_HaltonRsg,
  &_swigt__p_HandleT_BlackVolTermStructure_t,
  &_swigt__p_HandleT_CalibratedModel_t,
  &_swigt__p_HandleT_CapFloorTermVolatilityStructure_t,
  &_swigt__p_HandleT_DefaultProbabilityTermStructure_t,
  &_swigt__p_HandleT_DeltaVolQuote_t,
  &_swigt__p_HandleT_HestonModel_t,
  &_swigt__p_HandleT_LocalVolTermStructure_t,
  &_swigt__p_HandleT_OptionletVolatilityStructure_t,
  &_swigt__p_HandleT_Quote_t,
  &_swigt__p_HandleT_ShortRateModel_t,
  &_swigt__p_HandleT_SwaptionVolatilityStructure_t,
  &_swigt__p_HandleT_YieldTermStructure_t,
  &_swigt__p_HandleT_YoYInflationTermStructure_t,
  &_swigt__p_HandleT_YoYOptionletVolatilitySurface_t,
  &_swigt__p_HandleT_ZeroInflationTermStructure_t,
  &_swigt__p_HazardRate,
  &_swigt__p_HestonBlackVolSurface,
  &_swigt__p_HestonModel,
  &_swigt__p_HestonModelHelper,
  &_swigt__p_HestonProcess,
  &_swigt__p_HestonRNDCalculator,
  &_swigt__p_HestonSLVFDMModel,
  &_swigt__p_HestonSLVFokkerPlanckFdmParams,
  &_swigt__p_HestonSLVMCModel,
  &_swigt__p_HestonSLVProcess,
  &_swigt__p_HimalayaOption,
  &_swigt__p_HullWhite,
  &_swigt__p_HullWhiteForwardProcess,
  &_swigt__p_HullWhiteProcess,
  &_swigt__p_HundsdorferScheme,
  &_swigt__p_IMM,
  &_swigt__p_IborCoupon,
  &_swigt__p_IborCouponPricer,
  &_swigt__p_IborIndex,
  &_swigt__p_ImplicitEulerScheme,
  &_swigt__p_ImpliedTermStructure,
  &_swigt__p_IncrementalStatistics,
  &_swigt__p_Index,
  &_swigt__p_IndexManager,
  &_swigt__p_IndexedCashFlow,
  &_swigt__p_InflationCoupon,
  &_swigt__p_InflationIndex,
  &_swigt__p_InflationTermStructure,
  &_swigt__p_Instrument,
  &_swigt__p_IntegralCdsEngine,
  &_swigt__p_IntegralEngine,
  &_swigt__p_Integration,
  &_swigt__p_InterestRate,
  &_swigt__p_InterestRateIndex,
  &_swigt__p_InterpolatedDefaultDensityCurveT_Linear_t,
  &_swigt__p_InterpolatedDiscountCurveT_LogLinear_t,
  &_swigt__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t,
  &_swigt__p_InterpolatedDiscountCurveT_SplineCubic_t,
  &_swigt__p_InterpolatedForwardCurveT_BackwardFlat_t,
  &_swigt__p_InterpolatedHazardRateCurveT_BackwardFlat_t,
  &_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t,
  &_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t,
  &_swigt__p_InterpolatedSmileSectionT_Cubic_t,
  &_swigt__p_InterpolatedSmileSectionT_Linear_t,
  &_swigt__p_InterpolatedSmileSectionT_MonotonicCubic_t,
  &_swigt__p_InterpolatedSmileSectionT_SplineCubic_t,
  &_swigt__p_InterpolatedSurvivalProbabilityCurveT_Linear_t,
  &_swigt__p_InterpolatedYoYInflationCurveT_Linear_t,
  &_swigt__p_InterpolatedYoYOptionletStripperT_Linear_t,
  &_swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t,
  &_swigt__p_InterpolatedZeroCurveT_Cubic_t,
  &_swigt__p_InterpolatedZeroCurveT_DefaultLogCubic_t,
  &_swigt__p_InterpolatedZeroCurveT_Linear_t,
  &_swigt__p_InterpolatedZeroCurveT_LogLinear_t,
  &_swigt__p_InterpolatedZeroCurveT_MonotonicCubic_t,
  &_swigt__p_InterpolatedZeroCurveT_SplineCubic_t,
  &_swigt__p_InterpolatedZeroInflationCurveT_Linear_t,
  &_swigt__p_IntervalPrice,
  &_swigt__p_InverseCumulativeNormal,
  &_swigt__p_InverseCumulativePoisson,
  &_swigt__p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t,
  &_swigt__p_InverseCumulativeStudent,
  &_swigt__p_InverseNonCentralCumulativeChiSquareDistribution,
  &_swigt__p_IsdaCdsEngine,
  &_swigt__p_JPYLibor,
  &_swigt__p_JamshidianSwaptionEngine,
  &_swigt__p_Jibar,
  &_swigt__p_JpyLiborSwapIsdaFixAm,
  &_swigt__p_JpyLiborSwapIsdaFixPm,
  &_swigt__p_JuQuadraticApproximationEngine,
  &_swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t,
  &_swigt__p_KahaleSmileSection,
  &_swigt__p_KerkhofSeasonality,
  &_swigt__p_KirkEngine,
  &_swigt__p_KirkSpreadOptionEngine,
  &_swigt__p_KlugeExtOUProcess,
  &_swigt__p_KnuthUniformRng,
  &_swigt__p_Kruger,
  &_swigt__p_KrugerLog,
  &_swigt__p_LecuyerUniformRng,
  &_swigt__p_LevenbergMarquardt,
  &_swigt__p_Libor,
  &_swigt__p_Linear,
  &_swigt__p_LinearTsrPricer,
  &_swigt__p_LinearTsrPricer__Settings,
  &_swigt__p_LocalConstantVol,
  &_swigt__p_LocalVolRNDCalculator,
  &_swigt__p_LocalVolSurface,
  &_swigt__p_LocalVolTermStructure,
  &_swigt__p_LogLinear,
  &_swigt__p_LogNormalSimulatedAnnealing,
  &_swigt__p_LognormalCmsSpreadPricer,
  &_swigt__p_LsmBasisSystem,
  &_swigt__p_MCAmericanBasketEngineT_LowDiscrepancy_t,
  &_swigt__p_MCAmericanBasketEngineT_PseudoRandom_t,
  &_swigt__p_MCAmericanEngineT_LowDiscrepancy_t,
  &_swigt__p_MCAmericanEngineT_PseudoRandom_t,
  &_swigt__p_MCBarrierEngineT_LowDiscrepancy_t,
  &_swigt__p_MCBarrierEngineT_PseudoRandom_t,
  &_swigt__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t,
  &_swigt__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t,
  &_swigt__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t,
  &_swigt__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t,
  &_swigt__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t,
  &_swigt__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t,
  &_swigt__p_MCEuropeanBasketEngineT_LowDiscrepancy_t,
  &_swigt__p_MCEuropeanBasketEngineT_PseudoRandom_t,
  &_swigt__p_MCEuropeanEngineT_LowDiscrepancy_t,
  &_swigt__p_MCEuropeanEngineT_PseudoRandom_t,
  &_swigt__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t,
  &_swigt__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t,
  &_swigt__p_MCEuropeanHestonEngineT_LowDiscrepancy_t,
  &_swigt__p_MCEuropeanHestonEngineT_PseudoRandom_t,
  &_swigt__p_MCEverestEngineT_LowDiscrepancy_t,
  &_swigt__p_MCEverestEngineT_PseudoRandom_t,
  &_swigt__p_MCHimalayaEngineT_LowDiscrepancy_t,
  &_swigt__p_MCHimalayaEngineT_PseudoRandom_t,
  &_swigt__p_MTBrownianGeneratorFactory,
  &_swigt__p_MakeOIS,
  &_swigt__p_MakeSchedule,
  &_swigt__p_MakeVanillaSwap,
  &_swigt__p_MarkovFunctional,
  &_swigt__p_MarkovFunctional__ModelSettings,
  &_swigt__p_Matrix,
  &_swigt__p_MatrixMultiplicationProxy,
  &_swigt__p_MatrixRow,
  &_swigt__p_MaxBasketPayoff,
  &_swigt__p_MersenneTwisterUniformRng,
  &_swigt__p_Merton76Process,
  &_swigt__p_MethodOfLinesScheme,
  &_swigt__p_MidPointCdsEngine,
  &_swigt__p_MinBasketPayoff,
  &_swigt__p_MirrorGaussianSimulatedAnnealing,
  &_swigt__p_ModifiedCraigSneydScheme,
  &_swigt__p_Money,
  &_swigt__p_MonotonicCubic,
  &_swigt__p_MonotonicLogCubic,
  &_swigt__p_MoroInverseCumulativeNormal,
  &_swigt__p_Mosprime,
  &_swigt__p_MultiAssetOption,
  &_swigt__p_MultiPath,
  &_swigt__p_MultiplicativePriceSeasonality,
  &_swigt__p_NZDLibor,
  &_swigt__p_NelsonSiegelFitting,
  &_swigt__p_NeumannBC,
  &_swigt__p_Newton,
  &_swigt__p_NewtonSafe,
  &_swigt__p_NinePointLinearOp,
  &_swigt__p_NoArbSabrInterpolatedSmileSection,
  &_swigt__p_NoArbSabrSmileSection,
  &_swigt__p_NoConstraint,
  &_swigt__p_NoExceptLocalVolSurface,
  &_swigt__p_NonCentralCumulativeChiSquareDistribution,
  &_swigt__p_NonhomogeneousBoundaryConstraint,
  &_swigt__p_NonstandardSwap,
  &_swigt__p_NonstandardSwaption,
  &_swigt__p_NormalDistribution,
  &_swigt__p_NthOrderDerivativeOp,
  &_swigt__p_NullParameter,
  &_swigt__p_NumericHaganPricer,
  &_swigt__p_Nzocr,
  &_swigt__p_OISRateHelper,
  &_swigt__p_Observable,
  &_swigt__p_OneAssetOption,
  &_swigt__p_OneFactorAffineModel,
  &_swigt__p_OptimizationMethod,
  &_swigt__p_Optimizer,
  &_swigt__p_Option,
  &_swigt__p_OptionletStripper1,
  &_swigt__p_OptionletVolatilityStructure,
  &_swigt__p_OrnsteinUhlenbeckProcess,
  &_swigt__p_OvernightIndex,
  &_swigt__p_OvernightIndexFuture,
  &_swigt__p_OvernightIndexFutureRateHelper,
  &_swigt__p_OvernightIndexedCoupon,
  &_swigt__p_OvernightIndexedSwap,
  &_swigt__p_OvernightIndexedSwapIndex,
  &_swigt__p_Parameter,
  &_swigt__p_ParkinsonSigma,
  &_swigt__p_Path,
  &_swigt__p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t,
  &_swigt__p_PathGeneratorT_GaussianRandomSequenceGenerator_t,
  &_swigt__p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t,
  &_swigt__p_Payoff,
  &_swigt__p_PercentageStrikePayoff,
  &_swigt__p_Period,
  &_swigt__p_PeriodParser,
  &_swigt__p_PiecewiseConstantParameter,
  &_swigt__p_PiecewiseConvexMonotoneZero,
  &_swigt__p_PiecewiseCubicZero,
  &_swigt__p_PiecewiseFlatForward,
  &_swigt__p_PiecewiseFlatHazardRate,
  &_swigt__p_PiecewiseKrugerLogDiscount,
  &_swigt__p_PiecewiseKrugerZero,
  &_swigt__p_PiecewiseLinearForward,
  &_swigt__p_PiecewiseLinearZero,
  &_swigt__p_PiecewiseLogCubicDiscount,
  &_swigt__p_PiecewiseLogLinearDiscount,
  &_swigt__p_PiecewiseSplineCubicDiscount,
  &_swigt__p_PiecewiseTimeDependentHestonModel,
  &_swigt__p_PiecewiseYoYInflationCurveT_Linear_t,
  &_swigt__p_PiecewiseZeroInflationCurveT_Linear_t,
  &_swigt__p_Pillar,
  &_swigt__p_PlainVanillaPayoff,
  &_swigt__p_PoissonDistribution,
  &_swigt__p_Position,
  &_swigt__p_PositiveConstraint,
  &_swigt__p_Predefined1dMesher,
  &_swigt__p_Pribor,
  &_swigt__p_PricingEngine,
  &_swigt__p_ProbabilityBoltzmannDownhill,
  &_swigt__p_Protection,
  &_swigt__p_PyObserver,
  &_swigt__p_QuantLib__ARSCurrency,
  &_swigt__p_QuantLib__ATSCurrency,
  &_swigt__p_QuantLib__AUDCurrency,
  &_swigt__p_QuantLib__Actual360,
  &_swigt__p_QuantLib__Actual364,
  &_swigt__p_QuantLib__Actual365Fixed,
  &_swigt__p_QuantLib__ActualActual,
  &_swigt__p_QuantLib__Argentina,
  &_swigt__p_QuantLib__Australia,
  &_swigt__p_QuantLib__BDTCurrency,
  &_swigt__p_QuantLib__BEFCurrency,
  &_swigt__p_QuantLib__BGLCurrency,
  &_swigt__p_QuantLib__BRLCurrency,
  &_swigt__p_QuantLib__BYRCurrency,
  &_swigt__p_QuantLib__BespokeCalendar,
  &_swigt__p_QuantLib__Brazil,
  &_swigt__p_QuantLib__Business252,
  &_swigt__p_QuantLib__CADCurrency,
  &_swigt__p_QuantLib__CHFCurrency,
  &_swigt__p_QuantLib__CLPCurrency,
  &_swigt__p_QuantLib__CNYCurrency,
  &_swigt__p_QuantLib__COPCurrency,
  &_swigt__p_QuantLib__CYPCurrency,
  &_swigt__p_QuantLib__CZKCurrency,
  &_swigt__p_QuantLib__Canada,
  &_swigt__p_QuantLib__China,
  &_swigt__p_QuantLib__CzechRepublic,
  &_swigt__p_QuantLib__DEMCurrency,
  &_swigt__p_QuantLib__DKKCurrency,
  &_swigt__p_QuantLib__Denmark,
  &_swigt__p_QuantLib__EEKCurrency,
  &_swigt__p_QuantLib__ESPCurrency,
  &_swigt__p_QuantLib__EURCurrency,
  &_swigt__p_QuantLib__FIMCurrency,
  &_swigt__p_QuantLib__FRFCurrency,
  &_swigt__p_QuantLib__Finland,
  &_swigt__p_QuantLib__France,
  &_swigt__p_QuantLib__GBPCurrency,
  &_swigt__p_QuantLib__GRDCurrency,
  &_swigt__p_QuantLib__Germany,
  &_swigt__p_QuantLib__HKDCurrency,
  &_swigt__p_QuantLib__HUFCurrency,
  &_swigt__p_QuantLib__HongKong,
  &_swigt__p_QuantLib__Hungary,
  &_swigt__p_QuantLib__IDRCurrency,
  &_swigt__p_QuantLib__IEPCurrency,
  &_swigt__p_QuantLib__ILSCurrency,
  &_swigt__p_QuantLib__INRCurrency,
  &_swigt__p_QuantLib__IQDCurrency,
  &_swigt__p_QuantLib__IRRCurrency,
  &_swigt__p_QuantLib__ISKCurrency,
  &_swigt__p_QuantLib__ITLCurrency,
  &_swigt__p_QuantLib__Iceland,
  &_swigt__p_QuantLib__India,
  &_swigt__p_QuantLib__Indonesia,
  &_swigt__p_QuantLib__Israel,
  &_swigt__p_QuantLib__Italy,
  &_swigt__p_QuantLib__JPYCurrency,
  &_swigt__p_QuantLib__Japan,
  &_swigt__p_QuantLib__JointCalendar,
  &_swigt__p_QuantLib__KRWCurrency,
  &_swigt__p_QuantLib__KWDCurrency,
  &_swigt__p_QuantLib__LTLCurrency,
  &_swigt__p_QuantLib__LUFCurrency,
  &_swigt__p_QuantLib__LVLCurrency,
  &_swigt__p_QuantLib__MTLCurrency,
  &_swigt__p_QuantLib__MXNCurrency,
  &_swigt__p_QuantLib__MYRCurrency,
  &_swigt__p_QuantLib__Mexico,
  &_swigt__p_QuantLib__NLGCurrency,
  &_swigt__p_QuantLib__NOKCurrency,
  &_swigt__p_QuantLib__NPRCurrency,
  &_swigt__p_QuantLib__NZDCurrency,
  &_swigt__p_QuantLib__NewZealand,
  &_swigt__p_QuantLib__Norway,
  &_swigt__p_QuantLib__NullCalendar,
  &_swigt__p_QuantLib__OneDayCounter,
  &_swigt__p_QuantLib__PEHCurrency,
  &_swigt__p_QuantLib__PEICurrency,
  &_swigt__p_QuantLib__PENCurrency,
  &_swigt__p_QuantLib__PKRCurrency,
  &_swigt__p_QuantLib__PLNCurrency,
  &_swigt__p_QuantLib__PTECurrency,
  &_swigt__p_QuantLib__Poland,
  &_swigt__p_QuantLib__ROLCurrency,
  &_swigt__p_QuantLib__RONCurrency,
  &_swigt__p_QuantLib__RUBCurrency,
  &_swigt__p_QuantLib__Romania,
  &_swigt__p_QuantLib__Russia,
  &_swigt__p_QuantLib__SARCurrency,
  &_swigt__p_QuantLib__SEKCurrency,
  &_swigt__p_QuantLib__SGDCurrency,
  &_swigt__p_QuantLib__SITCurrency,
  &_swigt__p_QuantLib__SKKCurrency,
  &_swigt__p_QuantLib__SaudiArabia,
  &_swigt__p_QuantLib__SimpleDayCounter,
  &_swigt__p_QuantLib__Singapore,
  &_swigt__p_QuantLib__Slovakia,
  &_swigt__p_QuantLib__SouthAfrica,
  &_swigt__p_QuantLib__SouthKorea,
  &_swigt__p_QuantLib__Sweden,
  &_swigt__p_QuantLib__Switzerland,
  &_swigt__p_QuantLib__TARGET,
  &_swigt__p_QuantLib__THBCurrency,
  &_swigt__p_QuantLib__TRLCurrency,
  &_swigt__p_QuantLib__TRYCurrency,
  &_swigt__p_QuantLib__TTDCurrency,
  &_swigt__p_QuantLib__TWDCurrency,
  &_swigt__p_QuantLib__Taiwan,
  &_swigt__p_QuantLib__Thailand,
  &_swigt__p_QuantLib__Thirty360,
  &_swigt__p_QuantLib__Thirty365,
  &_swigt__p_QuantLib__Turkey,
  &_swigt__p_QuantLib__USDCurrency,
  &_swigt__p_QuantLib__Ukraine,
  &_swigt__p_QuantLib__UnitedKingdom,
  &_swigt__p_QuantLib__UnitedStates,
  &_swigt__p_QuantLib__VEBCurrency,
  &_swigt__p_QuantLib__VNDCurrency,
  &_swigt__p_QuantLib__WeekendsOnly,
  &_swigt__p_QuantLib__ZARCurrency,
  &_swigt__p_QuantoDoubleBarrierOption,
  &_swigt__p_QuantoEuropeanEngine,
  &_swigt__p_QuantoForwardEuropeanEngine,
  &_swigt__p_QuantoForwardVanillaOption,
  &_swigt__p_QuantoVanillaOption,
  &_swigt__p_Quote,
  &_swigt__p_RandomSequenceGeneratorT_KnuthUniformRng_t,
  &_swigt__p_RandomSequenceGeneratorT_LecuyerUniformRng_t,
  &_swigt__p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t,
  &_swigt__p_RateHelper,
  &_swigt__p_RealTimeSeries,
  &_swigt__p_ReannealingTrivial,
  &_swigt__p_RebatedExercise,
  &_swigt__p_Redemption,
  &_swigt__p_Region,
  &_swigt__p_RelinkableHandleT_BlackVolTermStructure_t,
  &_swigt__p_RelinkableHandleT_CalibratedModel_t,
  &_swigt__p_RelinkableHandleT_CapFloorTermVolatilityStructure_t,
  &_swigt__p_RelinkableHandleT_DefaultProbabilityTermStructure_t,
  &_swigt__p_RelinkableHandleT_DeltaVolQuote_t,
  &_swigt__p_RelinkableHandleT_LocalVolTermStructure_t,
  &_swigt__p_RelinkableHandleT_OptionletVolatilityStructure_t,
  &_swigt__p_RelinkableHandleT_Quote_t,
  &_swigt__p_RelinkableHandleT_ShortRateModel_t,
  &_swigt__p_RelinkableHandleT_SwaptionVolatilityStructure_t,
  &_swigt__p_RelinkableHandleT_YieldTermStructure_t,
  &_swigt__p_RelinkableHandleT_YoYInflationTermStructure_t,
  &_swigt__p_RelinkableHandleT_YoYOptionletVolatilitySurface_t,
  &_swigt__p_RelinkableHandleT_ZeroInflationTermStructure_t,
  &_swigt__p_RichardsonExtrapolation,
  &_swigt__p_Ridder,
  &_swigt__p_RiskNeutralDensityCalculator,
  &_swigt__p_RiskStatistics,
  &_swigt__p_Robor,
  &_swigt__p_Rounding,
  &_swigt__p_SEKLibor,
  &_swigt__p_SVD,
  &_swigt__p_SabrSmileSection,
  &_swigt__p_SafeBackwardFlatInterpolation,
  &_swigt__p_SafeBicubicSpline,
  &_swigt__p_SafeBilinearInterpolation,
  &_swigt__p_SafeConvexMonotoneInterpolation,
  &_swigt__p_SafeCubicNaturalSpline,
  &_swigt__p_SafeForwardFlatInterpolation,
  &_swigt__p_SafeFritschButlandCubic,
  &_swigt__p_SafeFritschButlandLogCubic,
  &_swigt__p_SafeKrugerCubic,
  &_swigt__p_SafeKrugerLogCubic,
  &_swigt__p_SafeLinearInterpolation,
  &_swigt__p_SafeLogCubicNaturalSpline,
  &_swigt__p_SafeLogLinearInterpolation,
  &_swigt__p_SafeLogParabolic,
  &_swigt__p_SafeMonotonicCubicNaturalSpline,
  &_swigt__p_SafeMonotonicLogCubicNaturalSpline,
  &_swigt__p_SafeMonotonicLogParabolic,
  &_swigt__p_SafeMonotonicParabolic,
  &_swigt__p_SafeParabolic,
  &_swigt__p_SafeSABRInterpolation,
  &_swigt__p_SalvagingAlgorithm,
  &_swigt__p_SampleT_Array_t,
  &_swigt__p_SampleT_MultiPath_t,
  &_swigt__p_SampleT_Path_t,
  &_swigt__p_SampleT_double_t,
  &_swigt__p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t,
  &_swigt__p_SampledCurve,
  &_swigt__p_SamplerGaussian,
  &_swigt__p_SamplerLogNormal,
  &_swigt__p_SamplerMirrorGaussian,
  &_swigt__p_Schedule,
  &_swigt__p_Seasonality,
  &_swigt__p_Secant,
  &_swigt__p_SecondDerivativeOp,
  &_swigt__p_SecondOrderMixedDerivativeOp,
  &_swigt__p_SegmentIntegral,
  &_swigt__p_Settings,
  &_swigt__p_Settlement,
  &_swigt__p_Shibor,
  &_swigt__p_ShortRateModel,
  &_swigt__p_Side,
  &_swigt__p_SimpleCashFlow,
  &_swigt__p_SimplePolynomialFitting,
  &_swigt__p_SimpleQuote,
  &_swigt__p_Simplex,
  &_swigt__p_SimpsonIntegral,
  &_swigt__p_SmileSection,
  &_swigt__p_SobolBrownianBridgeRsg,
  &_swigt__p_SobolBrownianGenerator,
  &_swigt__p_SobolBrownianGeneratorFactory,
  &_swigt__p_SobolRsg,
  &_swigt__p_Sofr,
  &_swigt__p_SofrFutureRateHelper,
  &_swigt__p_SoftCallability,
  &_swigt__p_Sonia,
  &_swigt__p_SplineCubic,
  &_swigt__p_SpreadBasketPayoff,
  &_swigt__p_SpreadCdsHelper,
  &_swigt__p_SpreadOption,
  &_swigt__p_SquareRootProcessRNDCalculator,
  &_swigt__p_Statistics,
  &_swigt__p_SteepestDescent,
  &_swigt__p_StepConditionT_Array_t,
  &_swigt__p_StochasticProcess,
  &_swigt__p_StochasticProcess1D,
  &_swigt__p_StochasticProcessArray,
  &_swigt__p_Stock,
  &_swigt__p_StrikedTypePayoff,
  &_swigt__p_StrippedOptionletAdapter,
  &_swigt__p_StrippedOptionletBase,
  &_swigt__p_StudentDistribution,
  &_swigt__p_StulzEngine,
  &_swigt__p_SuperSharePayoff,
  &_swigt__p_SvenssonFitting,
  &_swigt__p_Swap,
  &_swigt__p_SwapIndex,
  &_swigt__p_SwapRateHelper,
  &_swigt__p_SwapSpreadIndex,
  &_swigt__p_Swaption,
  &_swigt__p_SwaptionHelper,
  &_swigt__p_SwaptionVolCube1,
  &_swigt__p_SwaptionVolCube2,
  &_swigt__p_SwaptionVolatilityCube,
  &_swigt__p_SwaptionVolatilityDiscrete,
  &_swigt__p_SwaptionVolatilityMatrix,
  &_swigt__p_SwaptionVolatilityStructure,
  &_swigt__p_SwingExercise,
  &_swigt__p_THBFIX,
  &_swigt__p_TRLibor,
  &_swigt__p_TemperatureExponential,
  &_swigt__p_TermStructure,
  &_swigt__p_TermStructureConsistentModel,
  &_swigt__p_Tibor,
  &_swigt__p_TimeBasket,
  &_swigt__p_TimeGrid,
  &_swigt__p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,
  &_swigt__p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t,
  &_swigt__p_TrapezoidIntegralT_Default_t,
  &_swigt__p_TrapezoidIntegralT_MidPoint_t,
  &_swigt__p_TreeCallableFixedRateBondEngine,
  &_swigt__p_TreeCapFloorEngine,
  &_swigt__p_TreeSwaptionEngine,
  &_swigt__p_TridiagonalOperator,
  &_swigt__p_TripleBandLinearOp,
  &_swigt__p_TypePayoff,
  &_swigt__p_UKRPI,
  &_swigt__p_USCPI,
  &_swigt__p_USDLibor,
  &_swigt__p_USDLiborON,
  &_swigt__p_Uniform1dMesher,
  &_swigt__p_UniformLowDiscrepancySequenceGenerator,
  &_swigt__p_UniformRandomGenerator,
  &_swigt__p_UniformRandomSequenceGenerator,
  &_swigt__p_UpRounding,
  &_swigt__p_UpfrontCdsHelper,
  &_swigt__p_UsdLiborSwapIsdaFixAm,
  &_swigt__p_UsdLiborSwapIsdaFixPm,
  &_swigt__p_VanillaForwardPayoff,
  &_swigt__p_VanillaOption,
  &_swigt__p_VanillaSwap,
  &_swigt__p_VanillaSwingOption,
  &_swigt__p_VannaVolgaBarrierEngine,
  &_swigt__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t,
  &_swigt__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t,
  &_swigt__p_VarianceGammaEngine,
  &_swigt__p_VarianceGammaProcess,
  &_swigt__p_Vasicek,
  &_swigt__p_VolatilityTermStructure,
  &_swigt__p_Wibor,
  &_swigt__p_WulinYongDoubleBarrierEngine,
  &_swigt__p_YYEUHICP,
  &_swigt__p_YYEUHICPXT,
  &_swigt__p_YYEUHICPr,
  &_swigt__p_YYFRHICP,
  &_swigt__p_YYFRHICPr,
  &_swigt__p_YYUKRPI,
  &_swigt__p_YYUKRPIr,
  &_swigt__p_YYUSCPI,
  &_swigt__p_YYUSCPIr,
  &_swigt__p_YYZACPI,
  &_swigt__p_YYZACPIr,
  &_swigt__p_YearOnYearInflationSwap,
  &_swigt__p_YearOnYearInflationSwapHelper,
  &_swigt__p_YieldTermStructure,
  &_swigt__p_YoYCapFloorTermPriceSurface,
  &_swigt__p_YoYInflationBachelierCapFloorEngine,
  &_swigt__p_YoYInflationBlackCapFloorEngine,
  &_swigt__p_YoYInflationCap,
  &_swigt__p_YoYInflationCapFloor,
  &_swigt__p_YoYInflationCapFloorTermPriceSurface,
  &_swigt__p_YoYInflationCollar,
  &_swigt__p_YoYInflationFloor,
  &_swigt__p_YoYInflationIndex,
  &_swigt__p_YoYInflationTermStructure,
  &_swigt__p_YoYInflationUnitDisplacedBlackCapFloorEngine,
  &_swigt__p_YoYOptionletHelper,
  &_swigt__p_YoYOptionletStripper,
  &_swigt__p_YoYOptionletVolatilitySurface,
  &_swigt__p_ZACPI,
  &_swigt__p_ZabrFullFd,
  &_swigt__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t,
  &_swigt__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t,
  &_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t,
  &_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t,
  &_swigt__p_ZabrLocalVolatility,
  &_swigt__p_ZabrShortMaturityLognormal,
  &_swigt__p_ZabrShortMaturityNormal,
  &_swigt__p_ZabrSmileSectionT_ZabrFullFd_t,
  &_swigt__p_ZabrSmileSectionT_ZabrLocalVolatility_t,
  &_swigt__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t,
  &_swigt__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t,
  &_swigt__p_ZeroCouponBond,
  &_swigt__p_ZeroCouponInflationSwap,
  &_swigt__p_ZeroCouponInflationSwapHelper,
  &_swigt__p_ZeroInflationIndex,
  &_swigt__p_ZeroInflationTermStructure,
  &_swigt__p_ZeroSpreadedTermStructure,
  &_swigt__p_ZeroYield,
  &_swigt__p_Zibor,
  &_swigt__p__GlobalBootstrap,
  &_swigt__p__IterativeBootstrap,
  &_swigt__p_allocator_type,
  &_swigt__p_char,
  &_swigt__p_const_reference,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_ext__functionT_double_fdoubleF_t,
  &_swigt__p_ext__shared_ptrT_AUCPI_t,
  &_swigt__p_ext__shared_ptrT_AUDLibor_t,
  &_swigt__p_ext__shared_ptrT_AmericanExercise_t,
  &_swigt__p_ext__shared_ptrT_AmortizingFixedRateBond_t,
  &_swigt__p_ext__shared_ptrT_AmortizingFloatingRateBond_t,
  &_swigt__p_ext__shared_ptrT_AmortizingPayment_t,
  &_swigt__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticCEVEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticEuropeanEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticHaganPricer_t,
  &_swigt__p_ext__shared_ptrT_AnalyticHestonEngine_t,
  &_swigt__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t,
  &_swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t,
  &_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t,
  &_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t,
  &_swigt__p_ext__shared_ptrT_Aonia_t,
  &_swigt__p_ext__shared_ptrT_AssetOrNothingPayoff_t,
  &_swigt__p_ext__shared_ptrT_AssetSwap_t,
  &_swigt__p_ext__shared_ptrT_AverageBasketPayoff_t,
  &_swigt__p_ext__shared_ptrT_BFGS_t,
  &_swigt__p_ext__shared_ptrT_BSMRNDCalculator_t,
  &_swigt__p_ext__shared_ptrT_BachelierCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_BachelierSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t,
  &_swigt__p_ext__shared_ptrT_BarrierOption_t,
  &_swigt__p_ext__shared_ptrT_BasketOption_t,
  &_swigt__p_ext__shared_ptrT_BasketPayoff_t,
  &_swigt__p_ext__shared_ptrT_BatesEngine_t,
  &_swigt__p_ext__shared_ptrT_BatesModel_t,
  &_swigt__p_ext__shared_ptrT_BatesProcess_t,
  &_swigt__p_ext__shared_ptrT_Bbsw1M_t,
  &_swigt__p_ext__shared_ptrT_Bbsw2M_t,
  &_swigt__p_ext__shared_ptrT_Bbsw3M_t,
  &_swigt__p_ext__shared_ptrT_Bbsw4M_t,
  &_swigt__p_ext__shared_ptrT_Bbsw5M_t,
  &_swigt__p_ext__shared_ptrT_Bbsw6M_t,
  &_swigt__p_ext__shared_ptrT_Bbsw_t,
  &_swigt__p_ext__shared_ptrT_BermudanExercise_t,
  &_swigt__p_ext__shared_ptrT_BiCGstab_t,
  &_swigt__p_ext__shared_ptrT_Bibor1M_t,
  &_swigt__p_ext__shared_ptrT_Bibor1Y_t,
  &_swigt__p_ext__shared_ptrT_Bibor2M_t,
  &_swigt__p_ext__shared_ptrT_Bibor3M_t,
  &_swigt__p_ext__shared_ptrT_Bibor6M_t,
  &_swigt__p_ext__shared_ptrT_Bibor9M_t,
  &_swigt__p_ext__shared_ptrT_BiborSW_t,
  &_swigt__p_ext__shared_ptrT_Bibor_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t,
  &_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t,
  &_swigt__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t,
  &_swigt__p_ext__shared_ptrT_Bkbm1M_t,
  &_swigt__p_ext__shared_ptrT_Bkbm2M_t,
  &_swigt__p_ext__shared_ptrT_Bkbm3M_t,
  &_swigt__p_ext__shared_ptrT_Bkbm4M_t,
  &_swigt__p_ext__shared_ptrT_Bkbm5M_t,
  &_swigt__p_ext__shared_ptrT_Bkbm6M_t,
  &_swigt__p_ext__shared_ptrT_Bkbm_t,
  &_swigt__p_ext__shared_ptrT_BlackCalibrationHelper_t,
  &_swigt__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t,
  &_swigt__p_ext__shared_ptrT_BlackCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_BlackCdsOptionEngine_t,
  &_swigt__p_ext__shared_ptrT_BlackConstantVol_t,
  &_swigt__p_ext__shared_ptrT_BlackIborCouponPricer_t,
  &_swigt__p_ext__shared_ptrT_BlackKarasinski_t,
  &_swigt__p_ext__shared_ptrT_BlackProcess_t,
  &_swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t,
  &_swigt__p_ext__shared_ptrT_BlackScholesProcess_t,
  &_swigt__p_ext__shared_ptrT_BlackSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_BlackVarianceCurve_t,
  &_swigt__p_ext__shared_ptrT_BlackVarianceSurface_t,
  &_swigt__p_ext__shared_ptrT_BlackVolTermStructure_t,
  &_swigt__p_ext__shared_ptrT_BondHelper_t,
  &_swigt__p_ext__shared_ptrT_Bond_t,
  &_swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,
  &_swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,
  &_swigt__p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,
  &_swigt__p_ext__shared_ptrT_BoundaryConstraint_t,
  &_swigt__p_ext__shared_ptrT_BrownianGeneratorFactory_t,
  &_swigt__p_ext__shared_ptrT_CADLiborON_t,
  &_swigt__p_ext__shared_ptrT_CADLibor_t,
  &_swigt__p_ext__shared_ptrT_CEVRNDCalculator_t,
  &_swigt__p_ext__shared_ptrT_CHFLibor_t,
  &_swigt__p_ext__shared_ptrT_COSHestonEngine_t,
  &_swigt__p_ext__shared_ptrT_CPIBond_t,
  &_swigt__p_ext__shared_ptrT_CPICoupon_t,
  &_swigt__p_ext__shared_ptrT_CPISwap_t,
  &_swigt__p_ext__shared_ptrT_CalibratedModel_t,
  &_swigt__p_ext__shared_ptrT_CalibrationHelper_t,
  &_swigt__p_ext__shared_ptrT_Callability_t,
  &_swigt__p_ext__shared_ptrT_CallableBond_t,
  &_swigt__p_ext__shared_ptrT_CallableFixedRateBond_t,
  &_swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t,
  &_swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t,
  &_swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t,
  &_swigt__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t,
  &_swigt__p_ext__shared_ptrT_CapFloor_t,
  &_swigt__p_ext__shared_ptrT_CapHelper_t,
  &_swigt__p_ext__shared_ptrT_Cap_t,
  &_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t,
  &_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t,
  &_swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t,
  &_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t,
  &_swigt__p_ext__shared_ptrT_CashFlow_t,
  &_swigt__p_ext__shared_ptrT_CashOrNothingPayoff_t,
  &_swigt__p_ext__shared_ptrT_Cdor_t,
  &_swigt__p_ext__shared_ptrT_CdsOption_t,
  &_swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t,
  &_swigt__p_ext__shared_ptrT_Claim_t,
  &_swigt__p_ext__shared_ptrT_CmsCouponPricer_t,
  &_swigt__p_ext__shared_ptrT_CmsCoupon_t,
  &_swigt__p_ext__shared_ptrT_CmsMarket_t,
  &_swigt__p_ext__shared_ptrT_CmsRateBond_t,
  &_swigt__p_ext__shared_ptrT_CmsSpreadCouponPricer_t,
  &_swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t,
  &_swigt__p_ext__shared_ptrT_Collar_t,
  &_swigt__p_ext__shared_ptrT_CompositeConstraint_t,
  &_swigt__p_ext__shared_ptrT_CompositeInstrument_t,
  &_swigt__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t,
  &_swigt__p_ext__shared_ptrT_Concentrating1dMesher_t,
  &_swigt__p_ext__shared_ptrT_ConjugateGradient_t,
  &_swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t,
  &_swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t,
  &_swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t,
  &_swigt__p_ext__shared_ptrT_Constraint_t,
  &_swigt__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t,
  &_swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t,
  &_swigt__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t,
  &_swigt__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t,
  &_swigt__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t,
  &_swigt__p_ext__shared_ptrT_Coupon_t,
  &_swigt__p_ext__shared_ptrT_CoxIngersollRoss_t,
  &_swigt__p_ext__shared_ptrT_CraigSneydScheme_t,
  &_swigt__p_ext__shared_ptrT_CrankNicolsonScheme_t,
  &_swigt__p_ext__shared_ptrT_CreditDefaultSwap_t,
  &_swigt__p_ext__shared_ptrT_DKKLibor_t,
  &_swigt__p_ext__shared_ptrT_DailyTenorLibor_t,
  &_swigt__p_ext__shared_ptrT_DatedOISRateHelper_t,
  &_swigt__p_ext__shared_ptrT_DefaultBoundaryCondition_t,
  &_swigt__p_ext__shared_ptrT_DefaultProbabilityHelper_t,
  &_swigt__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t,
  &_swigt__p_ext__shared_ptrT_DeltaVolQuote_t,
  &_swigt__p_ext__shared_ptrT_DepositRateHelper_t,
  &_swigt__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t,
  &_swigt__p_ext__shared_ptrT_DifferentialEvolution_t,
  &_swigt__p_ext__shared_ptrT_DirichletBC_t,
  &_swigt__p_ext__shared_ptrT_DiscountingBondEngine_t,
  &_swigt__p_ext__shared_ptrT_DiscountingSwapEngine_t,
  &_swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t,
  &_swigt__p_ext__shared_ptrT_DividendBarrierOption_t,
  &_swigt__p_ext__shared_ptrT_DividendVanillaOption_t,
  &_swigt__p_ext__shared_ptrT_Dividend_t,
  &_swigt__p_ext__shared_ptrT_DoubleBarrierOption_t,
  &_swigt__p_ext__shared_ptrT_DouglasScheme_t,
  &_swigt__p_ext__shared_ptrT_EUHICPXT_t,
  &_swigt__p_ext__shared_ptrT_EUHICP_t,
  &_swigt__p_ext__shared_ptrT_EURLibor10M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor11M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor1M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor1Y_t,
  &_swigt__p_ext__shared_ptrT_EURLibor2M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor2W_t,
  &_swigt__p_ext__shared_ptrT_EURLibor3M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor4M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor5M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor6M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor7M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor8M_t,
  &_swigt__p_ext__shared_ptrT_EURLibor9M_t,
  &_swigt__p_ext__shared_ptrT_EURLiborSW_t,
  &_swigt__p_ext__shared_ptrT_EURLibor_t,
  &_swigt__p_ext__shared_ptrT_EndCriteria_t,
  &_swigt__p_ext__shared_ptrT_Eonia_t,
  &_swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t,
  &_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t,
  &_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t,
  &_swigt__p_ext__shared_ptrT_Euribor10M_t,
  &_swigt__p_ext__shared_ptrT_Euribor11M_t,
  &_swigt__p_ext__shared_ptrT_Euribor1M_t,
  &_swigt__p_ext__shared_ptrT_Euribor1Y_t,
  &_swigt__p_ext__shared_ptrT_Euribor2M_t,
  &_swigt__p_ext__shared_ptrT_Euribor2W_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_10M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_11M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_1M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_1Y_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_2M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_2W_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_3M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_3W_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_4M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_5M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_6M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_7M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_8M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_9M_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_SW_t,
  &_swigt__p_ext__shared_ptrT_Euribor365_t,
  &_swigt__p_ext__shared_ptrT_Euribor3M_t,
  &_swigt__p_ext__shared_ptrT_Euribor3W_t,
  &_swigt__p_ext__shared_ptrT_Euribor4M_t,
  &_swigt__p_ext__shared_ptrT_Euribor5M_t,
  &_swigt__p_ext__shared_ptrT_Euribor6M_t,
  &_swigt__p_ext__shared_ptrT_Euribor7M_t,
  &_swigt__p_ext__shared_ptrT_Euribor8M_t,
  &_swigt__p_ext__shared_ptrT_Euribor9M_t,
  &_swigt__p_ext__shared_ptrT_EuriborSW_t,
  &_swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t,
  &_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t,
  &_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t,
  &_swigt__p_ext__shared_ptrT_Euribor_t,
  &_swigt__p_ext__shared_ptrT_EuropeanExercise_t,
  &_swigt__p_ext__shared_ptrT_EuropeanOption_t,
  &_swigt__p_ext__shared_ptrT_EverestOption_t,
  &_swigt__p_ext__shared_ptrT_Exercise_t,
  &_swigt__p_ext__shared_ptrT_ExplicitEulerScheme_t,
  &_swigt__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t,
  &_swigt__p_ext__shared_ptrT_ExponentialJump1dMesher_t,
  &_swigt__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,
  &_swigt__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t,
  &_swigt__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t,
  &_swigt__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t,
  &_swigt__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t,
  &_swigt__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t,
  &_swigt__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t,
  &_swigt__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t,
  &_swigt__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t,
  &_swigt__p_ext__shared_ptrT_FFTVarianceGammaEngine_t,
  &_swigt__p_ext__shared_ptrT_FRHICP_t,
  &_swigt__p_ext__shared_ptrT_FaceValueAccrualClaim_t,
  &_swigt__p_ext__shared_ptrT_FaceValueClaim_t,
  &_swigt__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdBatesVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t,
  &_swigt__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t,
  &_swigt__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdCEVVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdG2SwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_FdHestonBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_FdHestonRebateEngine_t,
  &_swigt__p_ext__shared_ptrT_FdHestonVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdSabrVanillaEngine_t,
  &_swigt__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t,
  &_swigt__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t,
  &_swigt__p_ext__shared_ptrT_Fdm1DimSolver_t,
  &_swigt__p_ext__shared_ptrT_Fdm1dMesher_t,
  &_swigt__p_ext__shared_ptrT_Fdm2DimSolver_t,
  &_swigt__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t,
  &_swigt__p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t,
  &_swigt__p_ext__shared_ptrT_Fdm3DimSolver_t,
  &_swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t,
  &_swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t,
  &_swigt__p_ext__shared_ptrT_FdmAmericanStepCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmArithmeticAverageCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmBackwardSolver_t,
  &_swigt__p_ext__shared_ptrT_FdmBatesOp_t,
  &_swigt__p_ext__shared_ptrT_FdmBermudanStepCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t,
  &_swigt__p_ext__shared_ptrT_FdmBlackScholesMesher_t,
  &_swigt__p_ext__shared_ptrT_FdmBlackScholesOp_t,
  &_swigt__p_ext__shared_ptrT_FdmBoundaryCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmCEV1dMesher_t,
  &_swigt__p_ext__shared_ptrT_FdmCEVOp_t,
  &_swigt__p_ext__shared_ptrT_FdmCellAveragingInnerValue_t,
  &_swigt__p_ext__shared_ptrT_FdmDirichletBoundary_t,
  &_swigt__p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t,
  &_swigt__p_ext__shared_ptrT_FdmDividendHandler_t,
  &_swigt__p_ext__shared_ptrT_FdmDupire1dOp_t,
  &_swigt__p_ext__shared_ptrT_FdmG2Op_t,
  &_swigt__p_ext__shared_ptrT_FdmG2Solver_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonFwdOp_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonOp_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonSolver_t,
  &_swigt__p_ext__shared_ptrT_FdmHestonVarianceMesher_t,
  &_swigt__p_ext__shared_ptrT_FdmHullWhiteOp_t,
  &_swigt__p_ext__shared_ptrT_FdmHullWhiteSolver_t,
  &_swigt__p_ext__shared_ptrT_FdmIndicesOnBoundary_t,
  &_swigt__p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t,
  &_swigt__p_ext__shared_ptrT_FdmInnerValueCalculator_t,
  &_swigt__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t,
  &_swigt__p_ext__shared_ptrT_FdmLinearOpComposite_t,
  &_swigt__p_ext__shared_ptrT_FdmLinearOpLayout_t,
  &_swigt__p_ext__shared_ptrT_FdmLinearOp_t,
  &_swigt__p_ext__shared_ptrT_FdmLocalVolFwdOp_t,
  &_swigt__p_ext__shared_ptrT_FdmLogBasketInnerValue_t,
  &_swigt__p_ext__shared_ptrT_FdmLogInnerValue_t,
  &_swigt__p_ext__shared_ptrT_FdmMesherComposite_t,
  &_swigt__p_ext__shared_ptrT_FdmMesher_t,
  &_swigt__p_ext__shared_ptrT_FdmNdimSolverT_4_t_t,
  &_swigt__p_ext__shared_ptrT_FdmNdimSolverT_5_t_t,
  &_swigt__p_ext__shared_ptrT_FdmNdimSolverT_6_t_t,
  &_swigt__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t,
  &_swigt__p_ext__shared_ptrT_FdmQuantoHelper_t,
  &_swigt__p_ext__shared_ptrT_FdmSabrOp_t,
  &_swigt__p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t,
  &_swigt__p_ext__shared_ptrT_FdmSimpleStorageCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmSimpleSwingCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmSnapshotCondition_t,
  &_swigt__p_ext__shared_ptrT_FdmSquareRootFwdOp_t,
  &_swigt__p_ext__shared_ptrT_FdmStepConditionComposite_t,
  &_swigt__p_ext__shared_ptrT_FdmStepConditionProxy_t,
  &_swigt__p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t,
  &_swigt__p_ext__shared_ptrT_FdmZabrOp_t,
  &_swigt__p_ext__shared_ptrT_FdmZeroInnerValue_t,
  &_swigt__p_ext__shared_ptrT_FedFunds_t,
  &_swigt__p_ext__shared_ptrT_FirstDerivativeOp_t,
  &_swigt__p_ext__shared_ptrT_FittedBondDiscountCurve_t,
  &_swigt__p_ext__shared_ptrT_FixedDividend_t,
  &_swigt__p_ext__shared_ptrT_FixedRateBondForward_t,
  &_swigt__p_ext__shared_ptrT_FixedRateBondHelper_t,
  &_swigt__p_ext__shared_ptrT_FixedRateBond_t,
  &_swigt__p_ext__shared_ptrT_FixedRateCoupon_t,
  &_swigt__p_ext__shared_ptrT_FlatForward_t,
  &_swigt__p_ext__shared_ptrT_FlatHazardRate_t,
  &_swigt__p_ext__shared_ptrT_FlatSmileSection_t,
  &_swigt__p_ext__shared_ptrT_FloatFloatSwap_t,
  &_swigt__p_ext__shared_ptrT_FloatFloatSwaption_t,
  &_swigt__p_ext__shared_ptrT_FloatingRateBond_t,
  &_swigt__p_ext__shared_ptrT_FloatingRateCouponPricer_t,
  &_swigt__p_ext__shared_ptrT_FloatingRateCoupon_t,
  &_swigt__p_ext__shared_ptrT_Floor_t,
  &_swigt__p_ext__shared_ptrT_ForwardEuropeanEngine_t,
  &_swigt__p_ext__shared_ptrT_ForwardRateAgreement_t,
  &_swigt__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t,
  &_swigt__p_ext__shared_ptrT_ForwardVanillaOption_t,
  &_swigt__p_ext__shared_ptrT_Forward_t,
  &_swigt__p_ext__shared_ptrT_FraRateHelper_t,
  &_swigt__p_ext__shared_ptrT_FractionalDividend_t,
  &_swigt__p_ext__shared_ptrT_FuturesRateHelper_t,
  &_swigt__p_ext__shared_ptrT_FxSwapRateHelper_t,
  &_swigt__p_ext__shared_ptrT_G2ForwardProcess_t,
  &_swigt__p_ext__shared_ptrT_G2Process_t,
  &_swigt__p_ext__shared_ptrT_G2SwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_G2_t,
  &_swigt__p_ext__shared_ptrT_GBPLiborON_t,
  &_swigt__p_ext__shared_ptrT_GBPLibor_t,
  &_swigt__p_ext__shared_ptrT_GBSMRNDCalculator_t,
  &_swigt__p_ext__shared_ptrT_GJRGARCHModel_t,
  &_swigt__p_ext__shared_ptrT_GJRGARCHProcess_t,
  &_swigt__p_ext__shared_ptrT_GMRES_t,
  &_swigt__p_ext__shared_ptrT_GapPayoff_t,
  &_swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t,
  &_swigt__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_Gaussian1dModel_t,
  &_swigt__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_GaussianSimulatedAnnealing_t,
  &_swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t,
  &_swigt__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,
  &_swigt__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t,
  &_swigt__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t,
  &_swigt__p_ext__shared_ptrT_Glued1dMesher_t,
  &_swigt__p_ext__shared_ptrT_GsrProcess_t,
  &_swigt__p_ext__shared_ptrT_Gsr_t,
  &_swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t,
  &_swigt__p_ext__shared_ptrT_HestonModelHelper_t,
  &_swigt__p_ext__shared_ptrT_HestonModel_t,
  &_swigt__p_ext__shared_ptrT_HestonProcess_t,
  &_swigt__p_ext__shared_ptrT_HestonRNDCalculator_t,
  &_swigt__p_ext__shared_ptrT_HestonSLVProcess_t,
  &_swigt__p_ext__shared_ptrT_HimalayaOption_t,
  &_swigt__p_ext__shared_ptrT_HullWhiteForwardProcess_t,
  &_swigt__p_ext__shared_ptrT_HullWhiteProcess_t,
  &_swigt__p_ext__shared_ptrT_HullWhite_t,
  &_swigt__p_ext__shared_ptrT_HundsdorferScheme_t,
  &_swigt__p_ext__shared_ptrT_IborCouponPricer_t,
  &_swigt__p_ext__shared_ptrT_IborCoupon_t,
  &_swigt__p_ext__shared_ptrT_IborIndex_t,
  &_swigt__p_ext__shared_ptrT_ImplicitEulerScheme_t,
  &_swigt__p_ext__shared_ptrT_ImpliedTermStructure_t,
  &_swigt__p_ext__shared_ptrT_Index_t,
  &_swigt__p_ext__shared_ptrT_IndexedCashFlow_t,
  &_swigt__p_ext__shared_ptrT_InflationCoupon_t,
  &_swigt__p_ext__shared_ptrT_InflationIndex_t,
  &_swigt__p_ext__shared_ptrT_InflationTermStructure_t,
  &_swigt__p_ext__shared_ptrT_Instrument_t,
  &_swigt__p_ext__shared_ptrT_IntegralCdsEngine_t,
  &_swigt__p_ext__shared_ptrT_IntegralEngine_t,
  &_swigt__p_ext__shared_ptrT_InterestRateIndex_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t,
  &_swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_IsdaCdsEngine_t,
  &_swigt__p_ext__shared_ptrT_JPYLibor_t,
  &_swigt__p_ext__shared_ptrT_JamshidianSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_Jibar_t,
  &_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t,
  &_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t,
  &_swigt__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t,
  &_swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_KahaleSmileSection_t,
  &_swigt__p_ext__shared_ptrT_KerkhofSeasonality_t,
  &_swigt__p_ext__shared_ptrT_KirkEngine_t,
  &_swigt__p_ext__shared_ptrT_KirkSpreadOptionEngine_t,
  &_swigt__p_ext__shared_ptrT_KlugeExtOUProcess_t,
  &_swigt__p_ext__shared_ptrT_LevenbergMarquardt_t,
  &_swigt__p_ext__shared_ptrT_Libor_t,
  &_swigt__p_ext__shared_ptrT_LinearTsrPricer_t,
  &_swigt__p_ext__shared_ptrT_LocalConstantVol_t,
  &_swigt__p_ext__shared_ptrT_LocalVolRNDCalculator_t,
  &_swigt__p_ext__shared_ptrT_LocalVolSurface_t,
  &_swigt__p_ext__shared_ptrT_LocalVolTermStructure_t,
  &_swigt__p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t,
  &_swigt__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t,
  &_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t,
  &_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t,
  &_swigt__p_ext__shared_ptrT_MTBrownianGeneratorFactory_t,
  &_swigt__p_ext__shared_ptrT_MarkovFunctional_t,
  &_swigt__p_ext__shared_ptrT_MaxBasketPayoff_t,
  &_swigt__p_ext__shared_ptrT_Merton76Process_t,
  &_swigt__p_ext__shared_ptrT_MethodOfLinesScheme_t,
  &_swigt__p_ext__shared_ptrT_MidPointCdsEngine_t,
  &_swigt__p_ext__shared_ptrT_MinBasketPayoff_t,
  &_swigt__p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t,
  &_swigt__p_ext__shared_ptrT_ModifiedCraigSneydScheme_t,
  &_swigt__p_ext__shared_ptrT_Mosprime_t,
  &_swigt__p_ext__shared_ptrT_MultiAssetOption_t,
  &_swigt__p_ext__shared_ptrT_MultiplicativePriceSeasonality_t,
  &_swigt__p_ext__shared_ptrT_NZDLibor_t,
  &_swigt__p_ext__shared_ptrT_NeumannBC_t,
  &_swigt__p_ext__shared_ptrT_NinePointLinearOp_t,
  &_swigt__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t,
  &_swigt__p_ext__shared_ptrT_NoArbSabrSmileSection_t,
  &_swigt__p_ext__shared_ptrT_NoConstraint_t,
  &_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t,
  &_swigt__p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t,
  &_swigt__p_ext__shared_ptrT_NonstandardSwap_t,
  &_swigt__p_ext__shared_ptrT_NonstandardSwaption_t,
  &_swigt__p_ext__shared_ptrT_NthOrderDerivativeOp_t,
  &_swigt__p_ext__shared_ptrT_NumericHaganPricer_t,
  &_swigt__p_ext__shared_ptrT_Nzocr_t,
  &_swigt__p_ext__shared_ptrT_OISRateHelper_t,
  &_swigt__p_ext__shared_ptrT_Observable_t,
  &_swigt__p_ext__shared_ptrT_OneAssetOption_t,
  &_swigt__p_ext__shared_ptrT_OneFactorAffineModel_t,
  &_swigt__p_ext__shared_ptrT_OptimizationMethod_t,
  &_swigt__p_ext__shared_ptrT_Option_t,
  &_swigt__p_ext__shared_ptrT_OptionletStripper1_t,
  &_swigt__p_ext__shared_ptrT_OptionletVolatilityStructure_t,
  &_swigt__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,
  &_swigt__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t,
  &_swigt__p_ext__shared_ptrT_OvernightIndex_t,
  &_swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t,
  &_swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t,
  &_swigt__p_ext__shared_ptrT_OvernightIndexedSwap_t,
  &_swigt__p_ext__shared_ptrT_Payoff_t,
  &_swigt__p_ext__shared_ptrT_PercentageStrikePayoff_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseCubicZero_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseFlatForward_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseKrugerZero_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseLinearForward_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseLinearZero_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t,
  &_swigt__p_ext__shared_ptrT_PlainVanillaPayoff_t,
  &_swigt__p_ext__shared_ptrT_PositiveConstraint_t,
  &_swigt__p_ext__shared_ptrT_Predefined1dMesher_t,
  &_swigt__p_ext__shared_ptrT_Pribor_t,
  &_swigt__p_ext__shared_ptrT_PricingEngine_t,
  &_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t,
  &_swigt__p_ext__shared_ptrT_QuantoEuropeanEngine_t,
  &_swigt__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t,
  &_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t,
  &_swigt__p_ext__shared_ptrT_QuantoVanillaOption_t,
  &_swigt__p_ext__shared_ptrT_Quote_t,
  &_swigt__p_ext__shared_ptrT_RateHelper_t,
  &_swigt__p_ext__shared_ptrT_RebatedExercise_t,
  &_swigt__p_ext__shared_ptrT_Redemption_t,
  &_swigt__p_ext__shared_ptrT_RiskNeutralDensityCalculator_t,
  &_swigt__p_ext__shared_ptrT_Robor_t,
  &_swigt__p_ext__shared_ptrT_SEKLibor_t,
  &_swigt__p_ext__shared_ptrT_SabrSmileSection_t,
  &_swigt__p_ext__shared_ptrT_Seasonality_t,
  &_swigt__p_ext__shared_ptrT_SecondDerivativeOp_t,
  &_swigt__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t,
  &_swigt__p_ext__shared_ptrT_Shibor_t,
  &_swigt__p_ext__shared_ptrT_ShortRateModel_t,
  &_swigt__p_ext__shared_ptrT_SimpleCashFlow_t,
  &_swigt__p_ext__shared_ptrT_SimpleQuote_t,
  &_swigt__p_ext__shared_ptrT_Simplex_t,
  &_swigt__p_ext__shared_ptrT_SmileSection_t,
  &_swigt__p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t,
  &_swigt__p_ext__shared_ptrT_SofrFutureRateHelper_t,
  &_swigt__p_ext__shared_ptrT_Sofr_t,
  &_swigt__p_ext__shared_ptrT_SoftCallability_t,
  &_swigt__p_ext__shared_ptrT_Sonia_t,
  &_swigt__p_ext__shared_ptrT_SpreadBasketPayoff_t,
  &_swigt__p_ext__shared_ptrT_SpreadCdsHelper_t,
  &_swigt__p_ext__shared_ptrT_SpreadOption_t,
  &_swigt__p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t,
  &_swigt__p_ext__shared_ptrT_SteepestDescent_t,
  &_swigt__p_ext__shared_ptrT_StepConditionT_Array_t_t,
  &_swigt__p_ext__shared_ptrT_StochasticProcess1D_t,
  &_swigt__p_ext__shared_ptrT_StochasticProcessArray_t,
  &_swigt__p_ext__shared_ptrT_StochasticProcess_t,
  &_swigt__p_ext__shared_ptrT_Stock_t,
  &_swigt__p_ext__shared_ptrT_StrikedTypePayoff_t,
  &_swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t,
  &_swigt__p_ext__shared_ptrT_StrippedOptionletBase_t,
  &_swigt__p_ext__shared_ptrT_StulzEngine_t,
  &_swigt__p_ext__shared_ptrT_SuperSharePayoff_t,
  &_swigt__p_ext__shared_ptrT_SwapIndex_t,
  &_swigt__p_ext__shared_ptrT_SwapRateHelper_t,
  &_swigt__p_ext__shared_ptrT_SwapSpreadIndex_t,
  &_swigt__p_ext__shared_ptrT_Swap_t,
  &_swigt__p_ext__shared_ptrT_SwaptionHelper_t,
  &_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t,
  &_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t,
  &_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t,
  &_swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t,
  &_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t,
  &_swigt__p_ext__shared_ptrT_SwaptionVolatilityStructure_t,
  &_swigt__p_ext__shared_ptrT_Swaption_t,
  &_swigt__p_ext__shared_ptrT_SwingExercise_t,
  &_swigt__p_ext__shared_ptrT_THBFIX_t,
  &_swigt__p_ext__shared_ptrT_TRLibor_t,
  &_swigt__p_ext__shared_ptrT_TermStructureConsistentModel_t,
  &_swigt__p_ext__shared_ptrT_TermStructure_t,
  &_swigt__p_ext__shared_ptrT_Tibor_t,
  &_swigt__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t,
  &_swigt__p_ext__shared_ptrT_TreeCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_TreeSwaptionEngine_t,
  &_swigt__p_ext__shared_ptrT_TripleBandLinearOp_t,
  &_swigt__p_ext__shared_ptrT_TypePayoff_t,
  &_swigt__p_ext__shared_ptrT_UKRPI_t,
  &_swigt__p_ext__shared_ptrT_USCPI_t,
  &_swigt__p_ext__shared_ptrT_USDLiborON_t,
  &_swigt__p_ext__shared_ptrT_USDLibor_t,
  &_swigt__p_ext__shared_ptrT_Uniform1dMesher_t,
  &_swigt__p_ext__shared_ptrT_UpfrontCdsHelper_t,
  &_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t,
  &_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t,
  &_swigt__p_ext__shared_ptrT_VanillaForwardPayoff_t,
  &_swigt__p_ext__shared_ptrT_VanillaOption_t,
  &_swigt__p_ext__shared_ptrT_VanillaSwap_t,
  &_swigt__p_ext__shared_ptrT_VanillaSwingOption_t,
  &_swigt__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t,
  &_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t,
  &_swigt__p_ext__shared_ptrT_VarianceGammaEngine_t,
  &_swigt__p_ext__shared_ptrT_VarianceGammaProcess_t,
  &_swigt__p_ext__shared_ptrT_Vasicek_t,
  &_swigt__p_ext__shared_ptrT_VolatilityTermStructure_t,
  &_swigt__p_ext__shared_ptrT_Wibor_t,
  &_swigt__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t,
  &_swigt__p_ext__shared_ptrT_YYEUHICPXT_t,
  &_swigt__p_ext__shared_ptrT_YYEUHICP_t,
  &_swigt__p_ext__shared_ptrT_YYEUHICPr_t,
  &_swigt__p_ext__shared_ptrT_YYFRHICP_t,
  &_swigt__p_ext__shared_ptrT_YYFRHICPr_t,
  &_swigt__p_ext__shared_ptrT_YYUKRPI_t,
  &_swigt__p_ext__shared_ptrT_YYUKRPIr_t,
  &_swigt__p_ext__shared_ptrT_YYUSCPI_t,
  &_swigt__p_ext__shared_ptrT_YYUSCPIr_t,
  &_swigt__p_ext__shared_ptrT_YYZACPI_t,
  &_swigt__p_ext__shared_ptrT_YYZACPIr_t,
  &_swigt__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t,
  &_swigt__p_ext__shared_ptrT_YearOnYearInflationSwap_t,
  &_swigt__p_ext__shared_ptrT_YieldTermStructure_t,
  &_swigt__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationCapFloor_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationCap_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationCollar_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationFloor_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationIndex_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationTermStructure_t,
  &_swigt__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t,
  &_swigt__p_ext__shared_ptrT_YoYOptionletHelper_t,
  &_swigt__p_ext__shared_ptrT_YoYOptionletStripper_t,
  &_swigt__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t,
  &_swigt__p_ext__shared_ptrT_ZACPI_t,
  &_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t,
  &_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t,
  &_swigt__p_ext__shared_ptrT_ZeroCouponBond_t,
  &_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t,
  &_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwap_t,
  &_swigt__p_ext__shared_ptrT_ZeroInflationIndex_t,
  &_swigt__p_ext__shared_ptrT_ZeroInflationTermStructure_t,
  &_swigt__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t,
  &_swigt__p_ext__shared_ptrT_Zibor_t,
  &_swigt__p_ext__tupleT_double_double_bool_t,
  &_swigt__p_ext__tupleT_double_double_double_t,
  &_swigt__p_first_type,
  &_swigt__p_int,
  &_swigt__p_key_type,
  &_swigt__p_long,
  &_swigt__p_mapped_type,
  &_swigt__p_p_PyObject,
  &_swigt__p_sample_type,
  &_swigt__p_second_type,
  &_swigt__p_size_t,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_Date_t,
  &_swigt__p_std__allocatorT_HandleT_Quote_t_t,
  &_swigt__p_std__allocatorT_InterestRate_t,
  &_swigt__p_std__allocatorT_IntervalPrice_t,
  &_swigt__p_std__allocatorT_Period_t,
  &_swigt__p_std__allocatorT_RelinkableHandleT_Quote_t_t,
  &_swigt__p_std__allocatorT_bool_t,
  &_swigt__p_std__allocatorT_double_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_Callability_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_Dividend_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_Instrument_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_Quote_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t,
  &_swigt__p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t,
  &_swigt__p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t,
  &_swigt__p_std__allocatorT_int_t,
  &_swigt__p_std__allocatorT_std__pairT_Date_double_t_t,
  &_swigt__p_std__allocatorT_std__pairT_double_const_Date_t_t,
  &_swigt__p_std__allocatorT_std__pairT_double_double_t_t,
  &_swigt__p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t,
  &_swigt__p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t,
  &_swigt__p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t,
  &_swigt__p_std__allocatorT_unsigned_int_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__lessT_double_t,
  &_swigt__p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t,
  &_swigt__p_std__pairT_Date_double_t,
  &_swigt__p_std__pairT_double_double_t,
  &_swigt__p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t,
  &_swigt__p_std__pairT_size_t_size_t_t,
  &_swigt__p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t,
  &_swigt__p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t,
  &_swigt__p_std__vectorT_Date_std__allocatorT_Date_t_t,
  &_swigt__p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t,
  &_swigt__p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t,
  &_swigt__p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t,
  &_swigt__p_std__vectorT_Period_std__allocatorT_Period_t_t,
  &_swigt__p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t,
  &_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t,
  &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t,
  &_swigt__p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t,
  &_swigt__p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t,
  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
  &_swigt__p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t,
  &_swigt__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,
  &_swigt__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,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__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,
  &_swigt__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,
  &_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_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,
  &_swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_ASX[] = {  {&_swigt__p_ASX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AUCPI[] = {  {&_swigt__p_AUCPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AUDLibor[] = {  {&_swigt__p_AUDLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AdaptiveRungeKuttaT_double_t[] = {  {&_swigt__p_AdaptiveRungeKuttaT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AmericanExercise[] = {  {&_swigt__p_AmericanExercise, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AmortizingFixedRateBond[] = {  {&_swigt__p_AmortizingFixedRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AmortizingFloatingRateBond[] = {  {&_swigt__p_AmortizingFloatingRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AmortizingPayment[] = {  {&_swigt__p_AmortizingPayment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticBSMHullWhiteEngine[] = {  {&_swigt__p_AnalyticBSMHullWhiteEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticBarrierEngine[] = {  {&_swigt__p_AnalyticBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticBinaryBarrierEngine[] = {  {&_swigt__p_AnalyticBinaryBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticCEVEngine[] = {  {&_swigt__p_AnalyticCEVEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticCapFloorEngine[] = {  {&_swigt__p_AnalyticCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticContinuousGeometricAveragePriceAsianEngine[] = {  {&_swigt__p_AnalyticContinuousGeometricAveragePriceAsianEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDigitalAmericanEngine[] = {  {&_swigt__p_AnalyticDigitalAmericanEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDigitalAmericanKOEngine[] = {  {&_swigt__p_AnalyticDigitalAmericanKOEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDiscreteGeometricAveragePriceAsianEngine[] = {  {&_swigt__p_AnalyticDiscreteGeometricAveragePriceAsianEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine[] = {  {&_swigt__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDividendEuropeanEngine[] = {  {&_swigt__p_AnalyticDividendEuropeanEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDoubleBarrierBinaryEngine[] = {  {&_swigt__p_AnalyticDoubleBarrierBinaryEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticDoubleBarrierEngine[] = {  {&_swigt__p_AnalyticDoubleBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticEuropeanEngine[] = {  {&_swigt__p_AnalyticEuropeanEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticGJRGARCHEngine[] = {  {&_swigt__p_AnalyticGJRGARCHEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticHaganPricer[] = {  {&_swigt__p_AnalyticHaganPricer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticHestonEngine[] = {  {&_swigt__p_AnalyticHestonEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticHestonEngine__Integration[] = {  {&_swigt__p_AnalyticHestonEngine__Integration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnalyticPTDHestonEngine[] = {  {&_swigt__p_AnalyticPTDHestonEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AndreasenHugeLocalVolAdapter[] = {  {&_swigt__p_AndreasenHugeLocalVolAdapter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AndreasenHugeVolatilityAdapter[] = {  {&_swigt__p_AndreasenHugeVolatilityAdapter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AndreasenHugeVolatilityInterpl[] = {  {&_swigt__p_AndreasenHugeVolatilityInterpl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Aonia[] = {  {&_swigt__p_Aonia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Array[] = {  {&_swigt__p_Array, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AssetOrNothingPayoff[] = {  {&_swigt__p_AssetOrNothingPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AssetSwap[] = {  {&_swigt__p_AssetSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Average[] = {  {&_swigt__p_Average, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AverageBasketPayoff[] = {  {&_swigt__p_AverageBasketPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BFGS[] = {  {&_swigt__p_BFGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BSMRNDCalculator[] = {  {&_swigt__p_BSMRNDCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BachelierCapFloorEngine[] = {  {&_swigt__p_BachelierCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BachelierSwaptionEngine[] = {  {&_swigt__p_BachelierSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BackwardFlat[] = {  {&_swigt__p_BackwardFlat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BaroneAdesiWhaleyApproximationEngine[] = {  {&_swigt__p_BaroneAdesiWhaleyApproximationEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Barrier[] = {  {&_swigt__p_Barrier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BarrierOption[] = {  {&_swigt__p_BarrierOption, 0, 0, 0},  {&_swigt__p_DividendBarrierOption, _p_DividendBarrierOptionTo_p_BarrierOption, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BasketOption[] = {  {&_swigt__p_BasketOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BasketPayoff[] = {  {&_swigt__p_BasketPayoff, 0, 0, 0},  {&_swigt__p_MinBasketPayoff, _p_MinBasketPayoffTo_p_BasketPayoff, 0, 0},  {&_swigt__p_MaxBasketPayoff, _p_MaxBasketPayoffTo_p_BasketPayoff, 0, 0},  {&_swigt__p_AverageBasketPayoff, _p_AverageBasketPayoffTo_p_BasketPayoff, 0, 0},  {&_swigt__p_SpreadBasketPayoff, _p_SpreadBasketPayoffTo_p_BasketPayoff, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BatesEngine[] = {  {&_swigt__p_BatesEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BatesModel[] = {  {&_swigt__p_BatesModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BatesProcess[] = {  {&_swigt__p_BatesProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw[] = {  {&_swigt__p_Bbsw, 0, 0, 0},  {&_swigt__p_Bbsw6M, _p_Bbsw6MTo_p_Bbsw, 0, 0},  {&_swigt__p_Bbsw1M, _p_Bbsw1MTo_p_Bbsw, 0, 0},  {&_swigt__p_Bbsw3M, _p_Bbsw3MTo_p_Bbsw, 0, 0},  {&_swigt__p_Bbsw5M, _p_Bbsw5MTo_p_Bbsw, 0, 0},  {&_swigt__p_Bbsw2M, _p_Bbsw2MTo_p_Bbsw, 0, 0},  {&_swigt__p_Bbsw4M, _p_Bbsw4MTo_p_Bbsw, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw1M[] = {  {&_swigt__p_Bbsw1M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw2M[] = {  {&_swigt__p_Bbsw2M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw3M[] = {  {&_swigt__p_Bbsw3M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw4M[] = {  {&_swigt__p_Bbsw4M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw5M[] = {  {&_swigt__p_Bbsw5M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bbsw6M[] = {  {&_swigt__p_Bbsw6M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BermudanExercise[] = {  {&_swigt__p_BermudanExercise, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BiCGstab[] = {  {&_swigt__p_BiCGstab, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor[] = {  {&_swigt__p_BiborSW, _p_BiborSWTo_p_Bibor, 0, 0},  {&_swigt__p_Bibor6M, _p_Bibor6MTo_p_Bibor, 0, 0},  {&_swigt__p_Bibor1M, _p_Bibor1MTo_p_Bibor, 0, 0},  {&_swigt__p_Bibor, 0, 0, 0},  {&_swigt__p_Bibor3M, _p_Bibor3MTo_p_Bibor, 0, 0},  {&_swigt__p_Bibor2M, _p_Bibor2MTo_p_Bibor, 0, 0},  {&_swigt__p_Bibor9M, _p_Bibor9MTo_p_Bibor, 0, 0},  {&_swigt__p_Bibor1Y, _p_Bibor1YTo_p_Bibor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor1M[] = {  {&_swigt__p_Bibor1M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor1Y[] = {  {&_swigt__p_Bibor1Y, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor2M[] = {  {&_swigt__p_Bibor2M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor3M[] = {  {&_swigt__p_Bibor3M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor6M[] = {  {&_swigt__p_Bibor6M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bibor9M[] = {  {&_swigt__p_Bibor9M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BiborSW[] = {  {&_swigt__p_BiborSW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bicubic[] = {  {&_swigt__p_Bicubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t[] = {  {&_swigt__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_CoxRossRubinstein_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_CoxRossRubinstein_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_JarrowRudd_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_JarrowRudd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_Joshi4_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_Joshi4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_LeisenReimer_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_LeisenReimer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_Tian_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_Tian_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialConvertibleEngineT_Trigeorgis_t[] = {  {&_swigt__p_BinomialConvertibleEngineT_Trigeorgis_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDistribution[] = {  {&_swigt__p_BinomialDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t[] = {  {&_swigt__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_CoxRossRubinstein_t[] = {  {&_swigt__p_BinomialVanillaEngineT_CoxRossRubinstein_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_JarrowRudd_t[] = {  {&_swigt__p_BinomialVanillaEngineT_JarrowRudd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_Joshi4_t[] = {  {&_swigt__p_BinomialVanillaEngineT_Joshi4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_LeisenReimer_t[] = {  {&_swigt__p_BinomialVanillaEngineT_LeisenReimer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_Tian_t[] = {  {&_swigt__p_BinomialVanillaEngineT_Tian_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BinomialVanillaEngineT_Trigeorgis_t[] = {  {&_swigt__p_BinomialVanillaEngineT_Trigeorgis_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bisection[] = {  {&_swigt__p_Bisection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BivariateCumulativeNormalDistribution[] = {  {&_swigt__p_BivariateCumulativeNormalDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BivariateCumulativeNormalDistributionDr78[] = {  {&_swigt__p_BivariateCumulativeNormalDistributionDr78, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BivariateCumulativeNormalDistributionWe04DP[] = {  {&_swigt__p_BivariateCumulativeNormalDistributionWe04DP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BjerksundStenslandApproximationEngine[] = {  {&_swigt__p_BjerksundStenslandApproximationEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm[] = {  {&_swigt__p_Bkbm1M, _p_Bkbm1MTo_p_Bkbm, 0, 0},  {&_swigt__p_Bkbm3M, _p_Bkbm3MTo_p_Bkbm, 0, 0},  {&_swigt__p_Bkbm5M, _p_Bkbm5MTo_p_Bkbm, 0, 0},  {&_swigt__p_Bkbm, 0, 0, 0},  {&_swigt__p_Bkbm2M, _p_Bkbm2MTo_p_Bkbm, 0, 0},  {&_swigt__p_Bkbm4M, _p_Bkbm4MTo_p_Bkbm, 0, 0},  {&_swigt__p_Bkbm6M, _p_Bkbm6MTo_p_Bkbm, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm1M[] = {  {&_swigt__p_Bkbm1M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm2M[] = {  {&_swigt__p_Bkbm2M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm3M[] = {  {&_swigt__p_Bkbm3M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm4M[] = {  {&_swigt__p_Bkbm4M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm5M[] = {  {&_swigt__p_Bkbm5M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bkbm6M[] = {  {&_swigt__p_Bkbm6M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackCalculator[] = {  {&_swigt__p_BlackCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackCalibrationHelper[] = {  {&_swigt__p_BlackCalibrationHelper, 0, 0, 0},  {&_swigt__p_SwaptionHelper, _p_SwaptionHelperTo_p_BlackCalibrationHelper, 0, 0},  {&_swigt__p_CapHelper, _p_CapHelperTo_p_BlackCalibrationHelper, 0, 0},  {&_swigt__p_HestonModelHelper, _p_HestonModelHelperTo_p_BlackCalibrationHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackCallableFixedRateBondEngine[] = {  {&_swigt__p_BlackCallableFixedRateBondEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackCapFloorEngine[] = {  {&_swigt__p_BlackCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackCdsOptionEngine[] = {  {&_swigt__p_BlackCdsOptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackConstantVol[] = {  {&_swigt__p_BlackConstantVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackDeltaCalculator[] = {  {&_swigt__p_BlackDeltaCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackIborCouponPricer[] = {  {&_swigt__p_BlackIborCouponPricer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackKarasinski[] = {  {&_swigt__p_BlackKarasinski, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackProcess[] = {  {&_swigt__p_BlackProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackScholesMertonProcess[] = {  {&_swigt__p_BlackScholesMertonProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackScholesProcess[] = {  {&_swigt__p_BlackScholesProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackSwaptionEngine[] = {  {&_swigt__p_BlackSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackVarianceCurve[] = {  {&_swigt__p_BlackVarianceCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackVarianceSurface[] = {  {&_swigt__p_BlackVarianceSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BlackVolTermStructure[] = {  {&_swigt__p_BlackVolTermStructure, 0, 0, 0},  {&_swigt__p_BlackConstantVol, _p_BlackConstantVolTo_p_BlackVolTermStructure, 0, 0},  {&_swigt__p_BlackVarianceSurface, _p_BlackVarianceSurfaceTo_p_BlackVolTermStructure, 0, 0},  {&_swigt__p_HestonBlackVolSurface, _p_HestonBlackVolSurfaceTo_p_BlackVolTermStructure, 0, 0},  {&_swigt__p_AndreasenHugeVolatilityAdapter, _p_AndreasenHugeVolatilityAdapterTo_p_BlackVolTermStructure, 0, 0},  {&_swigt__p_BlackVarianceCurve, _p_BlackVarianceCurveTo_p_BlackVolTermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Bond[] = {  {&_swigt__p_ZeroCouponBond, _p_ZeroCouponBondTo_p_Bond, 0, 0},  {&_swigt__p_CallableZeroCouponBond, _p_CallableZeroCouponBondTo_p_Bond, 0, 0},  {&_swigt__p_ConvertibleZeroCouponBond, _p_ConvertibleZeroCouponBondTo_p_Bond, 0, 0},  {&_swigt__p_ConvertibleFixedCouponBond, _p_ConvertibleFixedCouponBondTo_p_Bond, 0, 0},  {&_swigt__p_CallableBond, _p_CallableBondTo_p_Bond, 0, 0},  {&_swigt__p_Bond, 0, 0, 0},  {&_swigt__p_CPIBond, _p_CPIBondTo_p_Bond, 0, 0},  {&_swigt__p_FixedRateBond, _p_FixedRateBondTo_p_Bond, 0, 0},  {&_swigt__p_AmortizingFixedRateBond, _p_AmortizingFixedRateBondTo_p_Bond, 0, 0},  {&_swigt__p_AmortizingFloatingRateBond, _p_AmortizingFloatingRateBondTo_p_Bond, 0, 0},  {&_swigt__p_FloatingRateBond, _p_FloatingRateBondTo_p_Bond, 0, 0},  {&_swigt__p_CmsRateBond, _p_CmsRateBondTo_p_Bond, 0, 0},  {&_swigt__p_ConvertibleFloatingRateBond, _p_ConvertibleFloatingRateBondTo_p_Bond, 0, 0},  {&_swigt__p_CallableFixedRateBond, _p_CallableFixedRateBondTo_p_Bond, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BondFunctions[] = {  {&_swigt__p_BondFunctions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BondHelper[] = {  {&_swigt__p_BondHelper, 0, 0, 0},  {&_swigt__p_FixedRateBondHelper, _p_FixedRateBondHelperTo_p_BondHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BootstrapHelperT_YoYInflationTermStructure_t[] = {  {&_swigt__p_YearOnYearInflationSwapHelper, _p_YearOnYearInflationSwapHelperTo_p_BootstrapHelperT_YoYInflationTermStructure_t, 0, 0},  {&_swigt__p_BootstrapHelperT_YoYInflationTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BootstrapHelperT_YoYOptionletVolatilitySurface_t[] = {  {&_swigt__p_YoYOptionletHelper, _p_YoYOptionletHelperTo_p_BootstrapHelperT_YoYOptionletVolatilitySurface_t, 0, 0},  {&_swigt__p_BootstrapHelperT_YoYOptionletVolatilitySurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BootstrapHelperT_ZeroInflationTermStructure_t[] = {  {&_swigt__p_ZeroCouponInflationSwapHelper, _p_ZeroCouponInflationSwapHelperTo_p_BootstrapHelperT_ZeroInflationTermStructure_t, 0, 0},  {&_swigt__p_BootstrapHelperT_ZeroInflationTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoundaryConstraint[] = {  {&_swigt__p_BoundaryConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoxMullerGaussianRngT_KnuthUniformRng_t[] = {  {&_swigt__p_BoxMullerGaussianRngT_KnuthUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoxMullerGaussianRngT_LecuyerUniformRng_t[] = {  {&_swigt__p_BoxMullerGaussianRngT_LecuyerUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t[] = {  {&_swigt__p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Brent[] = {  {&_swigt__p_Brent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BrownianBridge[] = {  {&_swigt__p_BrownianBridge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BrownianGeneratorFactory[] = {  {&_swigt__p_BrownianGeneratorFactory, 0, 0, 0},  {&_swigt__p_MTBrownianGeneratorFactory, _p_MTBrownianGeneratorFactoryTo_p_BrownianGeneratorFactory, 0, 0},  {&_swigt__p_SobolBrownianGeneratorFactory, _p_SobolBrownianGeneratorFactoryTo_p_BrownianGeneratorFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CADLibor[] = {  {&_swigt__p_CADLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CADLiborON[] = {  {&_swigt__p_CADLiborON, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CEVRNDCalculator[] = {  {&_swigt__p_CEVRNDCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CHFLibor[] = {  {&_swigt__p_CHFLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CLGaussianRngT_KnuthUniformRng_t[] = {  {&_swigt__p_CLGaussianRngT_KnuthUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CLGaussianRngT_LecuyerUniformRng_t[] = {  {&_swigt__p_CLGaussianRngT_LecuyerUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CLGaussianRngT_MersenneTwisterUniformRng_t[] = {  {&_swigt__p_CLGaussianRngT_MersenneTwisterUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_COSHestonEngine[] = {  {&_swigt__p_COSHestonEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CPI[] = {  {&_swigt__p_CPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CPIBond[] = {  {&_swigt__p_CPIBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CPICoupon[] = {  {&_swigt__p_CPICoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CPISwap[] = {  {&_swigt__p_CPISwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Calendar[] = {  {&_swigt__p_QuantLib__Thailand, _p_QuantLib__ThailandTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Russia, _p_QuantLib__RussiaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__NewZealand, _p_QuantLib__NewZealandTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Germany, _p_QuantLib__GermanyTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__WeekendsOnly, _p_QuantLib__WeekendsOnlyTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Taiwan, _p_QuantLib__TaiwanTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Hungary, _p_QuantLib__HungaryTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Australia, _p_QuantLib__AustraliaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Switzerland, _p_QuantLib__SwitzerlandTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__France, _p_QuantLib__FranceTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Iceland, _p_QuantLib__IcelandTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Turkey, _p_QuantLib__TurkeyTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Norway, _p_QuantLib__NorwayTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Japan, _p_QuantLib__JapanTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__CzechRepublic, _p_QuantLib__CzechRepublicTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Sweden, _p_QuantLib__SwedenTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Israel, _p_QuantLib__IsraelTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Indonesia, _p_QuantLib__IndonesiaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__SaudiArabia, _p_QuantLib__SaudiArabiaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Canada, _p_QuantLib__CanadaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Poland, _p_QuantLib__PolandTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__NullCalendar, _p_QuantLib__NullCalendarTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__JointCalendar, _p_QuantLib__JointCalendarTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__BespokeCalendar, _p_QuantLib__BespokeCalendarTo_p_Calendar, 0, 0},  {&_swigt__p_Calendar, 0, 0, 0},  {&_swigt__p_QuantLib__SouthKorea, _p_QuantLib__SouthKoreaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Brazil, _p_QuantLib__BrazilTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__UnitedKingdom, _p_QuantLib__UnitedKingdomTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Singapore, _p_QuantLib__SingaporeTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Mexico, _p_QuantLib__MexicoTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__China, _p_QuantLib__ChinaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__SouthAfrica, _p_QuantLib__SouthAfricaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Argentina, _p_QuantLib__ArgentinaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Romania, _p_QuantLib__RomaniaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Slovakia, _p_QuantLib__SlovakiaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Ukraine, _p_QuantLib__UkraineTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Finland, _p_QuantLib__FinlandTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__UnitedStates, _p_QuantLib__UnitedStatesTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Italy, _p_QuantLib__ItalyTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__Denmark, _p_QuantLib__DenmarkTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__India, _p_QuantLib__IndiaTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__TARGET, _p_QuantLib__TARGETTo_p_Calendar, 0, 0},  {&_swigt__p_QuantLib__HongKong, _p_QuantLib__HongKongTo_p_Calendar, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CalibratedModel[] = {  {&_swigt__p_BatesModel, _p_BatesModelTo_p_CalibratedModel, 0, 0},  {&_swigt__p_GJRGARCHModel, _p_GJRGARCHModelTo_p_CalibratedModel, 0, 0},  {&_swigt__p_ShortRateModel, _p_ShortRateModelTo_p_CalibratedModel, 0, 0},  {&_swigt__p_OneFactorAffineModel, _p_OneFactorAffineModelTo_p_CalibratedModel, 0, 0},  {&_swigt__p_BlackKarasinski, _p_BlackKarasinskiTo_p_CalibratedModel, 0, 0},  {&_swigt__p_G2, _p_G2To_p_CalibratedModel, 0, 0},  {&_swigt__p_Vasicek, _p_VasicekTo_p_CalibratedModel, 0, 0},  {&_swigt__p_HestonModel, _p_HestonModelTo_p_CalibratedModel, 0, 0},  {&_swigt__p_PiecewiseTimeDependentHestonModel, _p_PiecewiseTimeDependentHestonModelTo_p_CalibratedModel, 0, 0},  {&_swigt__p_CalibratedModel, 0, 0, 0},  {&_swigt__p_CoxIngersollRoss, _p_CoxIngersollRossTo_p_CalibratedModel, 0, 0},  {&_swigt__p_ExtendedCoxIngersollRoss, _p_ExtendedCoxIngersollRossTo_p_CalibratedModel, 0, 0},  {&_swigt__p_HullWhite, _p_HullWhiteTo_p_CalibratedModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CalibrationHelper[] = {  {&_swigt__p_CalibrationHelper, 0, 0, 0},  {&_swigt__p_BlackCalibrationHelper, _p_BlackCalibrationHelperTo_p_CalibrationHelper, 0, 0},  {&_swigt__p_SwaptionHelper, _p_SwaptionHelperTo_p_CalibrationHelper, 0, 0},  {&_swigt__p_CapHelper, _p_CapHelperTo_p_CalibrationHelper, 0, 0},  {&_swigt__p_HestonModelHelper, _p_HestonModelHelperTo_p_CalibrationHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CalibrationSet[] = {  {&_swigt__p_CalibrationSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Callability[] = {  {&_swigt__p_Callability, 0, 0, 0},  {&_swigt__p_SoftCallability, _p_SoftCallabilityTo_p_Callability, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CallabilityPrice[] = {  {&_swigt__p_CallabilityPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CallableBond[] = {  {&_swigt__p_CallableBond, 0, 0, 0},  {&_swigt__p_CallableZeroCouponBond, _p_CallableZeroCouponBondTo_p_CallableBond, 0, 0},  {&_swigt__p_CallableFixedRateBond, _p_CallableFixedRateBondTo_p_CallableBond, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CallableFixedRateBond[] = {  {&_swigt__p_CallableFixedRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CallableZeroCouponBond[] = {  {&_swigt__p_CallableZeroCouponBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Cap[] = {  {&_swigt__p_Cap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CapFloor[] = {  {&_swigt__p_Cap, _p_CapTo_p_CapFloor, 0, 0},  {&_swigt__p_CapFloor, 0, 0, 0},  {&_swigt__p_Collar, _p_CollarTo_p_CapFloor, 0, 0},  {&_swigt__p_Floor, _p_FloorTo_p_CapFloor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CapFloorTermVolCurve[] = {  {&_swigt__p_CapFloorTermVolCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CapFloorTermVolSurface[] = {  {&_swigt__p_CapFloorTermVolSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CapFloorTermVolatilityStructure[] = {  {&_swigt__p_CapFloorTermVolatilityStructure, 0, 0, 0},  {&_swigt__p_CapFloorTermVolSurface, _p_CapFloorTermVolSurfaceTo_p_CapFloorTermVolatilityStructure, 0, 0},  {&_swigt__p_CapFloorTermVolCurve, _p_CapFloorTermVolCurveTo_p_CapFloorTermVolatilityStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CapHelper[] = {  {&_swigt__p_CapHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CappedFlooredCmsCoupon[] = {  {&_swigt__p_CappedFlooredCmsCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CappedFlooredCmsSpreadCoupon[] = {  {&_swigt__p_CappedFlooredCmsSpreadCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CappedFlooredCoupon[] = {  {&_swigt__p_CappedFlooredCoupon, 0, 0, 0},  {&_swigt__p_CappedFlooredIborCoupon, _p_CappedFlooredIborCouponTo_p_CappedFlooredCoupon, 0, 0},  {&_swigt__p_CappedFlooredCmsSpreadCoupon, _p_CappedFlooredCmsSpreadCouponTo_p_CappedFlooredCoupon, 0, 0},  {&_swigt__p_CappedFlooredCmsCoupon, _p_CappedFlooredCmsCouponTo_p_CappedFlooredCoupon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CappedFlooredIborCoupon[] = {  {&_swigt__p_CappedFlooredIborCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CashFlow[] = {  {&_swigt__p_Dividend, _p_DividendTo_p_CashFlow, 0, 0},  {&_swigt__p_FixedDividend, _p_FixedDividendTo_p_CashFlow, 0, 0},  {&_swigt__p_FractionalDividend, _p_FractionalDividendTo_p_CashFlow, 0, 0},  {&_swigt__p_AmortizingPayment, _p_AmortizingPaymentTo_p_CashFlow, 0, 0},  {&_swigt__p_CappedFlooredCmsCoupon, _p_CappedFlooredCmsCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_FloatingRateCoupon, _p_FloatingRateCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_FixedRateCoupon, _p_FixedRateCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_CPICoupon, _p_CPICouponTo_p_CashFlow, 0, 0},  {&_swigt__p_CmsCoupon, _p_CmsCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_Coupon, _p_CouponTo_p_CashFlow, 0, 0},  {&_swigt__p_Redemption, _p_RedemptionTo_p_CashFlow, 0, 0},  {&_swigt__p_IborCoupon, _p_IborCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_CappedFlooredCmsSpreadCoupon, _p_CappedFlooredCmsSpreadCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_CappedFlooredIborCoupon, _p_CappedFlooredIborCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_CappedFlooredCoupon, _p_CappedFlooredCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_OvernightIndexedCoupon, _p_OvernightIndexedCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_CashFlow, 0, 0, 0},  {&_swigt__p_CmsSpreadCoupon, _p_CmsSpreadCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_InflationCoupon, _p_InflationCouponTo_p_CashFlow, 0, 0},  {&_swigt__p_IndexedCashFlow, _p_IndexedCashFlowTo_p_CashFlow, 0, 0},  {&_swigt__p_SimpleCashFlow, _p_SimpleCashFlowTo_p_CashFlow, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CashFlows[] = {  {&_swigt__p_CashFlows, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CashOrNothingPayoff[] = {  {&_swigt__p_CashOrNothingPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Cdor[] = {  {&_swigt__p_Cdor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CdsOption[] = {  {&_swigt__p_CdsOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CeilingTruncation[] = {  {&_swigt__p_CeilingTruncation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChfLiborSwapIsdaFix[] = {  {&_swigt__p_ChfLiborSwapIsdaFix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Claim[] = {  {&_swigt__p_FaceValueClaim, _p_FaceValueClaimTo_p_Claim, 0, 0},  {&_swigt__p_FaceValueAccrualClaim, _p_FaceValueAccrualClaimTo_p_Claim, 0, 0},  {&_swigt__p_Claim, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ClosestRounding[] = {  {&_swigt__p_ClosestRounding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsCoupon[] = {  {&_swigt__p_CmsCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsCouponPricer[] = {  {&_swigt__p_CmsCouponPricer, 0, 0, 0},  {&_swigt__p_AnalyticHaganPricer, _p_AnalyticHaganPricerTo_p_CmsCouponPricer, 0, 0},  {&_swigt__p_NumericHaganPricer, _p_NumericHaganPricerTo_p_CmsCouponPricer, 0, 0},  {&_swigt__p_LinearTsrPricer, _p_LinearTsrPricerTo_p_CmsCouponPricer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsMarket[] = {  {&_swigt__p_CmsMarket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsMarketCalibration[] = {  {&_swigt__p_CmsMarketCalibration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsRateBond[] = {  {&_swigt__p_CmsRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsSpreadCoupon[] = {  {&_swigt__p_CmsSpreadCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CmsSpreadCouponPricer[] = {  {&_swigt__p_CmsSpreadCouponPricer, 0, 0, 0},  {&_swigt__p_LognormalCmsSpreadPricer, _p_LognormalCmsSpreadPricerTo_p_CmsSpreadCouponPricer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Collar[] = {  {&_swigt__p_Collar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompositeConstraint[] = {  {&_swigt__p_CompositeConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompositeInstrument[] = {  {&_swigt__p_CompositeInstrument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompositeQuoteT_BinaryFunction_t[] = {  {&_swigt__p_CompositeQuoteT_BinaryFunction_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Concentrating1dMesher[] = {  {&_swigt__p_Concentrating1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Conditions[] = {  {&_swigt__p_Conditions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConjugateGradient[] = {  {&_swigt__p_ConjugateGradient, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantEstimator[] = {  {&_swigt__p_ConstantEstimator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantOptionletVolatility[] = {  {&_swigt__p_ConstantOptionletVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantParameter[] = {  {&_swigt__p_ConstantParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantSwaptionVolatility[] = {  {&_swigt__p_ConstantSwaptionVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstantYoYOptionletVolatility[] = {  {&_swigt__p_ConstantYoYOptionletVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Constraint[] = {  {&_swigt__p_Constraint, 0, 0, 0},  {&_swigt__p_BoundaryConstraint, _p_BoundaryConstraintTo_p_Constraint, 0, 0},  {&_swigt__p_NoConstraint, _p_NoConstraintTo_p_Constraint, 0, 0},  {&_swigt__p_PositiveConstraint, _p_PositiveConstraintTo_p_Constraint, 0, 0},  {&_swigt__p_CompositeConstraint, _p_CompositeConstraintTo_p_Constraint, 0, 0},  {&_swigt__p_NonhomogeneousBoundaryConstraint, _p_NonhomogeneousBoundaryConstraintTo_p_Constraint, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContinuousArithmeticAsianLevyEngine[] = {  {&_swigt__p_ContinuousArithmeticAsianLevyEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContinuousAveragingAsianOption[] = {  {&_swigt__p_ContinuousAveragingAsianOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConvertibleFixedCouponBond[] = {  {&_swigt__p_ConvertibleFixedCouponBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConvertibleFloatingRateBond[] = {  {&_swigt__p_ConvertibleFloatingRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConvertibleZeroCouponBond[] = {  {&_swigt__p_ConvertibleZeroCouponBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConvexMonotone[] = {  {&_swigt__p_ConvexMonotone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Coupon[] = {  {&_swigt__p_OvernightIndexedCoupon, _p_OvernightIndexedCouponTo_p_Coupon, 0, 0},  {&_swigt__p_CappedFlooredCoupon, _p_CappedFlooredCouponTo_p_Coupon, 0, 0},  {&_swigt__p_CappedFlooredIborCoupon, _p_CappedFlooredIborCouponTo_p_Coupon, 0, 0},  {&_swigt__p_CappedFlooredCmsSpreadCoupon, _p_CappedFlooredCmsSpreadCouponTo_p_Coupon, 0, 0},  {&_swigt__p_IborCoupon, _p_IborCouponTo_p_Coupon, 0, 0},  {&_swigt__p_CmsSpreadCoupon, _p_CmsSpreadCouponTo_p_Coupon, 0, 0},  {&_swigt__p_InflationCoupon, _p_InflationCouponTo_p_Coupon, 0, 0},  {&_swigt__p_Coupon, 0, 0, 0},  {&_swigt__p_CappedFlooredCmsCoupon, _p_CappedFlooredCmsCouponTo_p_Coupon, 0, 0},  {&_swigt__p_CPICoupon, _p_CPICouponTo_p_Coupon, 0, 0},  {&_swigt__p_FixedRateCoupon, _p_FixedRateCouponTo_p_Coupon, 0, 0},  {&_swigt__p_FloatingRateCoupon, _p_FloatingRateCouponTo_p_Coupon, 0, 0},  {&_swigt__p_CmsCoupon, _p_CmsCouponTo_p_Coupon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CoxIngersollRoss[] = {  {&_swigt__p_CoxIngersollRoss, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CraigSneydScheme[] = {  {&_swigt__p_CraigSneydScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CrankNicolsonScheme[] = {  {&_swigt__p_CrankNicolsonScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CreditDefaultSwap[] = {  {&_swigt__p_CreditDefaultSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Cubic[] = {  {&_swigt__p_Cubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CubicBSplinesFitting[] = {  {&_swigt__p_CubicBSplinesFitting, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CumulativeBinomialDistribution[] = {  {&_swigt__p_CumulativeBinomialDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CumulativeChiSquareDistribution[] = {  {&_swigt__p_CumulativeChiSquareDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CumulativeGammaDistribution[] = {  {&_swigt__p_CumulativeGammaDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CumulativeNormalDistribution[] = {  {&_swigt__p_CumulativeNormalDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CumulativePoissonDistribution[] = {  {&_swigt__p_CumulativePoissonDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CumulativeStudentDistribution[] = {  {&_swigt__p_CumulativeStudentDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Currency[] = {  {&_swigt__p_QuantLib__FRFCurrency, _p_QuantLib__FRFCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__GBPCurrency, _p_QuantLib__GBPCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__GRDCurrency, _p_QuantLib__GRDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__HKDCurrency, _p_QuantLib__HKDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__HUFCurrency, _p_QuantLib__HUFCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__IEPCurrency, _p_QuantLib__IEPCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__IDRCurrency, _p_QuantLib__IDRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ILSCurrency, _p_QuantLib__ILSCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__INRCurrency, _p_QuantLib__INRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__IQDCurrency, _p_QuantLib__IQDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__IRRCurrency, _p_QuantLib__IRRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ISKCurrency, _p_QuantLib__ISKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ITLCurrency, _p_QuantLib__ITLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__FIMCurrency, _p_QuantLib__FIMCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__EURCurrency, _p_QuantLib__EURCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ESPCurrency, _p_QuantLib__ESPCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__EEKCurrency, _p_QuantLib__EEKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__DKKCurrency, _p_QuantLib__DKKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__DEMCurrency, _p_QuantLib__DEMCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__CZKCurrency, _p_QuantLib__CZKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_Currency, 0, 0, 0},  {&_swigt__p_QuantLib__COPCurrency, _p_QuantLib__COPCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__CNYCurrency, _p_QuantLib__CNYCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__CLPCurrency, _p_QuantLib__CLPCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__CHFCurrency, _p_QuantLib__CHFCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__CADCurrency, _p_QuantLib__CADCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__BYRCurrency, _p_QuantLib__BYRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__BRLCurrency, _p_QuantLib__BRLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__BGLCurrency, _p_QuantLib__BGLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__BEFCurrency, _p_QuantLib__BEFCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__BDTCurrency, _p_QuantLib__BDTCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__AUDCurrency, _p_QuantLib__AUDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ATSCurrency, _p_QuantLib__ATSCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ARSCurrency, _p_QuantLib__ARSCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__CYPCurrency, _p_QuantLib__CYPCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__JPYCurrency, _p_QuantLib__JPYCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__KRWCurrency, _p_QuantLib__KRWCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__KWDCurrency, _p_QuantLib__KWDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__LTLCurrency, _p_QuantLib__LTLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__LUFCurrency, _p_QuantLib__LUFCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__LVLCurrency, _p_QuantLib__LVLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__MTLCurrency, _p_QuantLib__MTLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__MXNCurrency, _p_QuantLib__MXNCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__MYRCurrency, _p_QuantLib__MYRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__NLGCurrency, _p_QuantLib__NLGCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__NOKCurrency, _p_QuantLib__NOKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__NPRCurrency, _p_QuantLib__NPRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__NZDCurrency, _p_QuantLib__NZDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__PEHCurrency, _p_QuantLib__PEHCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__PEICurrency, _p_QuantLib__PEICurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__PENCurrency, _p_QuantLib__PENCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__PKRCurrency, _p_QuantLib__PKRCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__PLNCurrency, _p_QuantLib__PLNCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__PTECurrency, _p_QuantLib__PTECurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ROLCurrency, _p_QuantLib__ROLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__RONCurrency, _p_QuantLib__RONCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__RUBCurrency, _p_QuantLib__RUBCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__SARCurrency, _p_QuantLib__SARCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__SEKCurrency, _p_QuantLib__SEKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__SGDCurrency, _p_QuantLib__SGDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__SITCurrency, _p_QuantLib__SITCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__SKKCurrency, _p_QuantLib__SKKCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__THBCurrency, _p_QuantLib__THBCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__TRLCurrency, _p_QuantLib__TRLCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__TRYCurrency, _p_QuantLib__TRYCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__TTDCurrency, _p_QuantLib__TTDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__TWDCurrency, _p_QuantLib__TWDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__USDCurrency, _p_QuantLib__USDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__VEBCurrency, _p_QuantLib__VEBCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__VNDCurrency, _p_QuantLib__VNDCurrencyTo_p_Currency, 0, 0},  {&_swigt__p_QuantLib__ZARCurrency, _p_QuantLib__ZARCurrencyTo_p_Currency, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CustomRegion[] = {  {&_swigt__p_CustomRegion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DKKLibor[] = {  {&_swigt__p_DKKLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DMinus[] = {  {&_swigt__p_DMinus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DPlus[] = {  {&_swigt__p_DPlus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DPlusDMinus[] = {  {&_swigt__p_DPlusDMinus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DZero[] = {  {&_swigt__p_DZero, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DailyTenorLibor[] = {  {&_swigt__p_DailyTenorLibor, 0, 0, 0},  {&_swigt__p_CADLiborON, _p_CADLiborONTo_p_DailyTenorLibor, 0, 0},  {&_swigt__p_GBPLiborON, _p_GBPLiborONTo_p_DailyTenorLibor, 0, 0},  {&_swigt__p_USDLiborON, _p_USDLiborONTo_p_DailyTenorLibor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Date[] = {  {&_swigt__p_Date, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DateGeneration[] = {  {&_swigt__p_DateGeneration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DateParser[] = {  {&_swigt__p_DateParser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DatedOISRateHelper[] = {  {&_swigt__p_DatedOISRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DayCounter[] = {  {&_swigt__p_DayCounter, 0, 0, 0},  {&_swigt__p_QuantLib__Thirty360, _p_QuantLib__Thirty360To_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__OneDayCounter, _p_QuantLib__OneDayCounterTo_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__SimpleDayCounter, _p_QuantLib__SimpleDayCounterTo_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__Actual360, _p_QuantLib__Actual360To_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__Actual365Fixed, _p_QuantLib__Actual365FixedTo_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__Business252, _p_QuantLib__Business252To_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__Thirty365, _p_QuantLib__Thirty365To_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__ActualActual, _p_QuantLib__ActualActualTo_p_DayCounter, 0, 0},  {&_swigt__p_QuantLib__Actual364, _p_QuantLib__Actual364To_p_DayCounter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultBoundaryCondition[] = {  {&_swigt__p_DefaultBoundaryCondition, 0, 0, 0},  {&_swigt__p_NeumannBC, _p_NeumannBCTo_p_DefaultBoundaryCondition, 0, 0},  {&_swigt__p_DirichletBC, _p_DirichletBCTo_p_DefaultBoundaryCondition, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultDensity[] = {  {&_swigt__p_DefaultDensity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultLexicographicalView[] = {  {&_swigt__p_DefaultLexicographicalView, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultLexicographicalViewColumn[] = {  {&_swigt__p_DefaultLexicographicalViewColumn, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultLogCubic[] = {  {&_swigt__p_DefaultLogCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultProbabilityHelper[] = {  {&_swigt__p_DefaultProbabilityHelper, 0, 0, 0},  {&_swigt__p_SpreadCdsHelper, _p_SpreadCdsHelperTo_p_DefaultProbabilityHelper, 0, 0},  {&_swigt__p_UpfrontCdsHelper, _p_UpfrontCdsHelperTo_p_DefaultProbabilityHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefaultProbabilityTermStructure[] = {  {&_swigt__p_InterpolatedDefaultDensityCurveT_Linear_t, _p_InterpolatedDefaultDensityCurveT_Linear_tTo_p_DefaultProbabilityTermStructure, 0, 0},  {&_swigt__p_InterpolatedSurvivalProbabilityCurveT_Linear_t, _p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_DefaultProbabilityTermStructure, 0, 0},  {&_swigt__p_DefaultProbabilityTermStructure, 0, 0, 0},  {&_swigt__p_InterpolatedHazardRateCurveT_BackwardFlat_t, _p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_DefaultProbabilityTermStructure, 0, 0},  {&_swigt__p_FlatHazardRate, _p_FlatHazardRateTo_p_DefaultProbabilityTermStructure, 0, 0},  {&_swigt__p_PiecewiseFlatHazardRate, _p_PiecewiseFlatHazardRateTo_p_DefaultProbabilityTermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DeltaVolQuote[] = {  {&_swigt__p_DeltaVolQuote, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DepositRateHelper[] = {  {&_swigt__p_DepositRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DerivedQuoteT_UnaryFunction_t[] = {  {&_swigt__p_DerivedQuoteT_UnaryFunction_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DifferentialEvolution[] = {  {&_swigt__p_DifferentialEvolution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DirichletBC[] = {  {&_swigt__p_DirichletBC, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Discount[] = {  {&_swigt__p_Discount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DiscountingBondEngine[] = {  {&_swigt__p_DiscountingBondEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DiscountingSwapEngine[] = {  {&_swigt__p_DiscountingSwapEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DiscreteAveragingAsianOption[] = {  {&_swigt__p_DiscreteAveragingAsianOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DisposableT_Array_t[] = {  {&_swigt__p_DisposableT_Array_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dividend[] = {  {&_swigt__p_Dividend, 0, 0, 0},  {&_swigt__p_FixedDividend, _p_FixedDividendTo_p_Dividend, 0, 0},  {&_swigt__p_FractionalDividend, _p_FractionalDividendTo_p_Dividend, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DividendBarrierOption[] = {  {&_swigt__p_DividendBarrierOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DividendVanillaOption[] = {  {&_swigt__p_DividendVanillaOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DoubleBarrier[] = {  {&_swigt__p_DoubleBarrier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DoubleBarrierOption[] = {  {&_swigt__p_DoubleBarrierOption, 0, 0, 0},  {&_swigt__p_QuantoDoubleBarrierOption, _p_QuantoDoubleBarrierOptionTo_p_DoubleBarrierOption, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DouglasScheme[] = {  {&_swigt__p_DouglasScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DownRounding[] = {  {&_swigt__p_DownRounding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Duration[] = {  {&_swigt__p_Duration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EUHICP[] = {  {&_swigt__p_EUHICP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EUHICPXT[] = {  {&_swigt__p_EUHICPXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor[] = {  {&_swigt__p_EURLiborSW, _p_EURLiborSWTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor4M, _p_EURLibor4MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor1Y, _p_EURLibor1YTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor3M, _p_EURLibor3MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor2M, _p_EURLibor2MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor11M, _p_EURLibor11MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor1M, _p_EURLibor1MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor10M, _p_EURLibor10MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor9M, _p_EURLibor9MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor8M, _p_EURLibor8MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor7M, _p_EURLibor7MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor, 0, 0, 0},  {&_swigt__p_EURLibor6M, _p_EURLibor6MTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor2W, _p_EURLibor2WTo_p_EURLibor, 0, 0},  {&_swigt__p_EURLibor5M, _p_EURLibor5MTo_p_EURLibor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor10M[] = {  {&_swigt__p_EURLibor10M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor11M[] = {  {&_swigt__p_EURLibor11M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor1M[] = {  {&_swigt__p_EURLibor1M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor1Y[] = {  {&_swigt__p_EURLibor1Y, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor2M[] = {  {&_swigt__p_EURLibor2M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor2W[] = {  {&_swigt__p_EURLibor2W, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor3M[] = {  {&_swigt__p_EURLibor3M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor4M[] = {  {&_swigt__p_EURLibor4M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor5M[] = {  {&_swigt__p_EURLibor5M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor6M[] = {  {&_swigt__p_EURLibor6M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor7M[] = {  {&_swigt__p_EURLibor7M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor8M[] = {  {&_swigt__p_EURLibor8M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLibor9M[] = {  {&_swigt__p_EURLibor9M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EURLiborSW[] = {  {&_swigt__p_EURLiborSW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EndCriteria[] = {  {&_swigt__p_EndCriteria, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EndCriteria__Type[] = {  {&_swigt__p_EndCriteria__Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Eonia[] = {  {&_swigt__p_Eonia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EurLiborSwapIfrFix[] = {  {&_swigt__p_EurLiborSwapIfrFix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EurLiborSwapIsdaFixA[] = {  {&_swigt__p_EurLiborSwapIsdaFixA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EurLiborSwapIsdaFixB[] = {  {&_swigt__p_EurLiborSwapIsdaFixB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor[] = {  {&_swigt__p_EuriborSW, _p_EuriborSWTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor4M, _p_Euribor4MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor, 0, 0, 0},  {&_swigt__p_Euribor1Y, _p_Euribor1YTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor3M, _p_Euribor3MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor2M, _p_Euribor2MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor11M, _p_Euribor11MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor1M, _p_Euribor1MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor10M, _p_Euribor10MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor9M, _p_Euribor9MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor8M, _p_Euribor8MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor7M, _p_Euribor7MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor3W, _p_Euribor3WTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor6M, _p_Euribor6MTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor2W, _p_Euribor2WTo_p_Euribor, 0, 0},  {&_swigt__p_Euribor5M, _p_Euribor5MTo_p_Euribor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor10M[] = {  {&_swigt__p_Euribor10M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor11M[] = {  {&_swigt__p_Euribor11M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor1M[] = {  {&_swigt__p_Euribor1M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor1Y[] = {  {&_swigt__p_Euribor1Y, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor2M[] = {  {&_swigt__p_Euribor2M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor2W[] = {  {&_swigt__p_Euribor2W, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365[] = {  {&_swigt__p_Euribor365_1M, _p_Euribor365_1MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_9M, _p_Euribor365_9MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_11M, _p_Euribor365_11MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_10M, _p_Euribor365_10MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_8M, _p_Euribor365_8MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_7M, _p_Euribor365_7MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_3W, _p_Euribor365_3WTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_6M, _p_Euribor365_6MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_2W, _p_Euribor365_2WTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_5M, _p_Euribor365_5MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_SW, _p_Euribor365_SWTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_4M, _p_Euribor365_4MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_1Y, _p_Euribor365_1YTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365_3M, _p_Euribor365_3MTo_p_Euribor365, 0, 0},  {&_swigt__p_Euribor365, 0, 0, 0},  {&_swigt__p_Euribor365_2M, _p_Euribor365_2MTo_p_Euribor365, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_10M[] = {  {&_swigt__p_Euribor365_10M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_11M[] = {  {&_swigt__p_Euribor365_11M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_1M[] = {  {&_swigt__p_Euribor365_1M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_1Y[] = {  {&_swigt__p_Euribor365_1Y, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_2M[] = {  {&_swigt__p_Euribor365_2M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_2W[] = {  {&_swigt__p_Euribor365_2W, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_3M[] = {  {&_swigt__p_Euribor365_3M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_3W[] = {  {&_swigt__p_Euribor365_3W, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_4M[] = {  {&_swigt__p_Euribor365_4M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_5M[] = {  {&_swigt__p_Euribor365_5M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_6M[] = {  {&_swigt__p_Euribor365_6M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_7M[] = {  {&_swigt__p_Euribor365_7M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_8M[] = {  {&_swigt__p_Euribor365_8M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_9M[] = {  {&_swigt__p_Euribor365_9M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor365_SW[] = {  {&_swigt__p_Euribor365_SW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor3M[] = {  {&_swigt__p_Euribor3M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor3W[] = {  {&_swigt__p_Euribor3W, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor4M[] = {  {&_swigt__p_Euribor4M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor5M[] = {  {&_swigt__p_Euribor5M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor6M[] = {  {&_swigt__p_Euribor6M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor7M[] = {  {&_swigt__p_Euribor7M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor8M[] = {  {&_swigt__p_Euribor8M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Euribor9M[] = {  {&_swigt__p_Euribor9M, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EuriborSW[] = {  {&_swigt__p_EuriborSW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EuriborSwapIfrFix[] = {  {&_swigt__p_EuriborSwapIfrFix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EuriborSwapIsdaFixA[] = {  {&_swigt__p_EuriborSwapIsdaFixA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EuriborSwapIsdaFixB[] = {  {&_swigt__p_EuriborSwapIsdaFixB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EuropeanExercise[] = {  {&_swigt__p_EuropeanExercise, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EuropeanOption[] = {  {&_swigt__p_EuropeanOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EverestOption[] = {  {&_swigt__p_EverestOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExchangeRate[] = {  {&_swigt__p_ExchangeRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExchangeRateManager[] = {  {&_swigt__p_ExchangeRateManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Exercise[] = {  {&_swigt__p_Exercise, 0, 0, 0},  {&_swigt__p_EuropeanExercise, _p_EuropeanExerciseTo_p_Exercise, 0, 0},  {&_swigt__p_AmericanExercise, _p_AmericanExerciseTo_p_Exercise, 0, 0},  {&_swigt__p_BermudanExercise, _p_BermudanExerciseTo_p_Exercise, 0, 0},  {&_swigt__p_RebatedExercise, _p_RebatedExerciseTo_p_Exercise, 0, 0},  {&_swigt__p_SwingExercise, _p_SwingExerciseTo_p_Exercise, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExplicitEulerScheme[] = {  {&_swigt__p_ExplicitEulerScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExponentialFittingHestonEngine[] = {  {&_swigt__p_ExponentialFittingHestonEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExponentialJump1dMesher[] = {  {&_swigt__p_ExponentialJump1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExponentialSplinesFitting[] = {  {&_swigt__p_ExponentialSplinesFitting, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExtOUWithJumpsProcess[] = {  {&_swigt__p_ExtOUWithJumpsProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExtendedCoxIngersollRoss[] = {  {&_swigt__p_ExtendedCoxIngersollRoss, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExtendedOrnsteinUhlenbeckProcess[] = {  {&_swigt__p_ExtendedOrnsteinUhlenbeckProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FDAmericanEngineT_CrankNicolson_t[] = {  {&_swigt__p_FDAmericanEngineT_CrankNicolson_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FDBermudanEngineT_CrankNicolson_t[] = {  {&_swigt__p_FDBermudanEngineT_CrankNicolson_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FDDividendAmericanEngineT_CrankNicolson_t[] = {  {&_swigt__p_FDDividendAmericanEngineT_CrankNicolson_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FDDividendEuropeanEngineT_CrankNicolson_t[] = {  {&_swigt__p_FDDividendEuropeanEngineT_CrankNicolson_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FDEuropeanEngineT_CrankNicolson_t[] = {  {&_swigt__p_FDEuropeanEngineT_CrankNicolson_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FDShoutEngineT_CrankNicolson_t[] = {  {&_swigt__p_FDShoutEngineT_CrankNicolson_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FFTVarianceGammaEngine[] = {  {&_swigt__p_FFTVarianceGammaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FRHICP[] = {  {&_swigt__p_FRHICP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FaceValueAccrualClaim[] = {  {&_swigt__p_FaceValueAccrualClaim, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FaceValueClaim[] = {  {&_swigt__p_FaceValueClaim, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FalsePosition[] = {  {&_swigt__p_FalsePosition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fd2dBlackScholesVanillaEngine[] = {  {&_swigt__p_Fd2dBlackScholesVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdBatesVanillaEngine[] = {  {&_swigt__p_FdBatesVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdBlackScholesAsianEngine[] = {  {&_swigt__p_FdBlackScholesAsianEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdBlackScholesBarrierEngine[] = {  {&_swigt__p_FdBlackScholesBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdBlackScholesRebateEngine[] = {  {&_swigt__p_FdBlackScholesRebateEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdBlackScholesVanillaEngine[] = {  {&_swigt__p_FdBlackScholesVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdCEVVanillaEngine[] = {  {&_swigt__p_FdCEVVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdG2SwaptionEngine[] = {  {&_swigt__p_FdG2SwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdHestonBarrierEngine[] = {  {&_swigt__p_FdHestonBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdHestonDoubleBarrierEngine[] = {  {&_swigt__p_FdHestonDoubleBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdHestonRebateEngine[] = {  {&_swigt__p_FdHestonRebateEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdHestonVanillaEngine[] = {  {&_swigt__p_FdHestonVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdHullWhiteSwaptionEngine[] = {  {&_swigt__p_FdHullWhiteSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdOrnsteinUhlenbeckVanillaEngine[] = {  {&_swigt__p_FdOrnsteinUhlenbeckVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdSabrVanillaEngine[] = {  {&_swigt__p_FdSabrVanillaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdSimpleBSSwingEngine[] = {  {&_swigt__p_FdSimpleBSSwingEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdSimpleExtOUJumpSwingEngine[] = {  {&_swigt__p_FdSimpleExtOUJumpSwingEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fdm1DimSolver[] = {  {&_swigt__p_Fdm1DimSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fdm1dMesher[] = {  {&_swigt__p_Fdm1dMesher, 0, 0, 0},  {&_swigt__p_Concentrating1dMesher, _p_Concentrating1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_ExponentialJump1dMesher, _p_ExponentialJump1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_FdmCEV1dMesher, _p_FdmCEV1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_FdmSimpleProcess1dMesher, _p_FdmSimpleProcess1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_Uniform1dMesher, _p_Uniform1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_Predefined1dMesher, _p_Predefined1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_Glued1dMesher, _p_Glued1dMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_FdmBlackScholesMesher, _p_FdmBlackScholesMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_FdmHestonVarianceMesher, _p_FdmHestonVarianceMesherTo_p_Fdm1dMesher, 0, 0},  {&_swigt__p_FdmHestonLocalVolatilityVarianceMesher, _p_FdmHestonLocalVolatilityVarianceMesherTo_p_Fdm1dMesher, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fdm2DimSolver[] = {  {&_swigt__p_Fdm2DimSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fdm2dBlackScholesOp[] = {  {&_swigt__p_Fdm2dBlackScholesOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fdm2dBlackScholesSolver[] = {  {&_swigt__p_Fdm2dBlackScholesSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fdm3DimSolver[] = {  {&_swigt__p_Fdm3DimSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmAffineModelSwapInnerValueT_G2_t[] = {  {&_swigt__p_FdmAffineModelSwapInnerValueT_G2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmAffineModelSwapInnerValueT_HullWhite_t[] = {  {&_swigt__p_FdmAffineModelSwapInnerValueT_HullWhite_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmAmericanStepCondition[] = {  {&_swigt__p_FdmAmericanStepCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmArithmeticAverageCondition[] = {  {&_swigt__p_FdmArithmeticAverageCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBackwardSolver[] = {  {&_swigt__p_FdmBackwardSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBatesOp[] = {  {&_swigt__p_FdmBatesOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBermudanStepCondition[] = {  {&_swigt__p_FdmBermudanStepCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBlackScholesFwdOp[] = {  {&_swigt__p_FdmBlackScholesFwdOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBlackScholesMesher[] = {  {&_swigt__p_FdmBlackScholesMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBlackScholesOp[] = {  {&_swigt__p_FdmBlackScholesOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmBoundaryCondition[] = {  {&_swigt__p_FdmBoundaryCondition, 0, 0, 0},  {&_swigt__p_FdmDirichletBoundary, _p_FdmDirichletBoundaryTo_p_FdmBoundaryCondition, 0, 0},  {&_swigt__p_FdmDiscountDirichletBoundary, _p_FdmDiscountDirichletBoundaryTo_p_FdmBoundaryCondition, 0, 0},  {&_swigt__p_FdmTimeDepDirichletBoundary, _p_FdmTimeDepDirichletBoundaryTo_p_FdmBoundaryCondition, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmCEV1dMesher[] = {  {&_swigt__p_FdmCEV1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmCEVOp[] = {  {&_swigt__p_FdmCEVOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmCellAveragingInnerValue[] = {  {&_swigt__p_FdmCellAveragingInnerValue, 0, 0, 0},  {&_swigt__p_FdmLogInnerValue, _p_FdmLogInnerValueTo_p_FdmCellAveragingInnerValue, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmDirichletBoundary[] = {  {&_swigt__p_FdmDirichletBoundary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmDiscountDirichletBoundary[] = {  {&_swigt__p_FdmDiscountDirichletBoundary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmDividendHandler[] = {  {&_swigt__p_FdmDividendHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmDupire1dOp[] = {  {&_swigt__p_FdmDupire1dOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmG2Op[] = {  {&_swigt__p_FdmG2Op, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmG2Solver[] = {  {&_swigt__p_FdmG2Solver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonFwdOp[] = {  {&_swigt__p_FdmHestonFwdOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonGreensFct[] = {  {&_swigt__p_FdmHestonGreensFct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonHullWhiteOp[] = {  {&_swigt__p_FdmHestonHullWhiteOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonHullWhiteSolver[] = {  {&_swigt__p_FdmHestonHullWhiteSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonLocalVolatilityVarianceMesher[] = {  {&_swigt__p_FdmHestonLocalVolatilityVarianceMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonOp[] = {  {&_swigt__p_FdmHestonOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonSolver[] = {  {&_swigt__p_FdmHestonSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHestonVarianceMesher[] = {  {&_swigt__p_FdmHestonVarianceMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHullWhiteOp[] = {  {&_swigt__p_FdmHullWhiteOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmHullWhiteSolver[] = {  {&_swigt__p_FdmHullWhiteSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmIndicesOnBoundary[] = {  {&_swigt__p_FdmIndicesOnBoundary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmInnerValueCalculator[] = {  {&_swigt__p_FdmCellAveragingInnerValue, _p_FdmCellAveragingInnerValueTo_p_FdmInnerValueCalculator, 0, 0},  {&_swigt__p_FdmLogInnerValue, _p_FdmLogInnerValueTo_p_FdmInnerValueCalculator, 0, 0},  {&_swigt__p_FdmLogBasketInnerValue, _p_FdmLogBasketInnerValueTo_p_FdmInnerValueCalculator, 0, 0},  {&_swigt__p_FdmZeroInnerValue, _p_FdmZeroInnerValueTo_p_FdmInnerValueCalculator, 0, 0},  {&_swigt__p_FdmInnerValueCalculator, 0, 0, 0},  {&_swigt__p_FdmAffineModelSwapInnerValueT_G2_t, _p_FdmAffineModelSwapInnerValueT_G2_tTo_p_FdmInnerValueCalculator, 0, 0},  {&_swigt__p_FdmAffineModelSwapInnerValueT_HullWhite_t, _p_FdmAffineModelSwapInnerValueT_HullWhite_tTo_p_FdmInnerValueCalculator, 0, 0},  {&_swigt__p_FdmInnerValueCalculatorProxy, _p_FdmInnerValueCalculatorProxyTo_p_FdmInnerValueCalculator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmInnerValueCalculatorProxy[] = {  {&_swigt__p_FdmInnerValueCalculatorProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLinearOp[] = {  {&_swigt__p_Fdm2dBlackScholesOp, _p_Fdm2dBlackScholesOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmBlackScholesOp, _p_FdmBlackScholesOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmSquareRootFwdOp, _p_FdmSquareRootFwdOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmZabrOp, _p_FdmZabrOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmLocalVolFwdOp, _p_FdmLocalVolFwdOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmLinearOpCompositeProxy, _p_FdmLinearOpCompositeProxyTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_TripleBandLinearOp, _p_TripleBandLinearOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_NinePointLinearOp, _p_NinePointLinearOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmLinearOp, 0, 0, 0},  {&_swigt__p_FdmHullWhiteOp, _p_FdmHullWhiteOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmHestonHullWhiteOp, _p_FdmHestonHullWhiteOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmLinearOpComposite, _p_FdmLinearOpCompositeTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmSabrOp, _p_FdmSabrOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmHestonFwdOp, _p_FdmHestonFwdOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmHestonOp, _p_FdmHestonOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmCEVOp, _p_FdmCEVOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmG2Op, _p_FdmG2OpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_SecondDerivativeOp, _p_SecondDerivativeOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FirstDerivativeOp, _p_FirstDerivativeOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_SecondOrderMixedDerivativeOp, _p_SecondOrderMixedDerivativeOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_NthOrderDerivativeOp, _p_NthOrderDerivativeOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmBatesOp, _p_FdmBatesOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmDupire1dOp, _p_FdmDupire1dOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmOrnsteinUhlenbeckOp, _p_FdmOrnsteinUhlenbeckOpTo_p_FdmLinearOp, 0, 0},  {&_swigt__p_FdmBlackScholesFwdOp, _p_FdmBlackScholesFwdOpTo_p_FdmLinearOp, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLinearOpComposite[] = {  {&_swigt__p_Fdm2dBlackScholesOp, _p_Fdm2dBlackScholesOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmBlackScholesOp, _p_FdmBlackScholesOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmSquareRootFwdOp, _p_FdmSquareRootFwdOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmZabrOp, _p_FdmZabrOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmLocalVolFwdOp, _p_FdmLocalVolFwdOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmLinearOpCompositeProxy, _p_FdmLinearOpCompositeProxyTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmHullWhiteOp, _p_FdmHullWhiteOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmHestonHullWhiteOp, _p_FdmHestonHullWhiteOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmLinearOpComposite, 0, 0, 0},  {&_swigt__p_FdmSabrOp, _p_FdmSabrOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmHestonFwdOp, _p_FdmHestonFwdOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmHestonOp, _p_FdmHestonOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmCEVOp, _p_FdmCEVOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmG2Op, _p_FdmG2OpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmBatesOp, _p_FdmBatesOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmDupire1dOp, _p_FdmDupire1dOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmOrnsteinUhlenbeckOp, _p_FdmOrnsteinUhlenbeckOpTo_p_FdmLinearOpComposite, 0, 0},  {&_swigt__p_FdmBlackScholesFwdOp, _p_FdmBlackScholesFwdOpTo_p_FdmLinearOpComposite, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLinearOpCompositeProxy[] = {  {&_swigt__p_FdmLinearOpCompositeProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLinearOpIterator[] = {  {&_swigt__p_FdmLinearOpIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLinearOpLayout[] = {  {&_swigt__p_FdmLinearOpLayout, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLocalVolFwdOp[] = {  {&_swigt__p_FdmLocalVolFwdOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLogBasketInnerValue[] = {  {&_swigt__p_FdmLogBasketInnerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmLogInnerValue[] = {  {&_swigt__p_FdmLogInnerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmMesher[] = {  {&_swigt__p_FdmMesherComposite, _p_FdmMesherCompositeTo_p_FdmMesher, 0, 0},  {&_swigt__p_FdmMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmMesherComposite[] = {  {&_swigt__p_FdmMesherComposite, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmNdimSolverT_4_t[] = {  {&_swigt__p_FdmNdimSolverT_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmNdimSolverT_5_t[] = {  {&_swigt__p_FdmNdimSolverT_5_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmNdimSolverT_6_t[] = {  {&_swigt__p_FdmNdimSolverT_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmOrnsteinUhlenbeckOp[] = {  {&_swigt__p_FdmOrnsteinUhlenbeckOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmQuantoHelper[] = {  {&_swigt__p_FdmQuantoHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSabrOp[] = {  {&_swigt__p_FdmSabrOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSchemeDesc[] = {  {&_swigt__p_FdmSchemeDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSimpleProcess1dMesher[] = {  {&_swigt__p_FdmSimpleProcess1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSimpleStorageCondition[] = {  {&_swigt__p_FdmSimpleStorageCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSimpleSwingCondition[] = {  {&_swigt__p_FdmSimpleSwingCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSnapshotCondition[] = {  {&_swigt__p_FdmSnapshotCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSolverDesc[] = {  {&_swigt__p_FdmSolverDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmSquareRootFwdOp[] = {  {&_swigt__p_FdmSquareRootFwdOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmStepConditionComposite[] = {  {&_swigt__p_FdmStepConditionComposite, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmStepConditionProxy[] = {  {&_swigt__p_FdmStepConditionProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmTimeDepDirichletBoundary[] = {  {&_swigt__p_FdmTimeDepDirichletBoundary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmZabrOp[] = {  {&_swigt__p_FdmZabrOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FdmZeroInnerValue[] = {  {&_swigt__p_FdmZeroInnerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FedFunds[] = {  {&_swigt__p_FedFunds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FirstDerivativeOp[] = {  {&_swigt__p_FirstDerivativeOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FittedBondDiscountCurve[] = {  {&_swigt__p_FittedBondDiscountCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FittingMethod[] = {  {&_swigt__p_ExponentialSplinesFitting, _p_ExponentialSplinesFittingTo_p_FittingMethod, 0, 0},  {&_swigt__p_NelsonSiegelFitting, _p_NelsonSiegelFittingTo_p_FittingMethod, 0, 0},  {&_swigt__p_SvenssonFitting, _p_SvenssonFittingTo_p_FittingMethod, 0, 0},  {&_swigt__p_CubicBSplinesFitting, _p_CubicBSplinesFittingTo_p_FittingMethod, 0, 0},  {&_swigt__p_SimplePolynomialFitting, _p_SimplePolynomialFittingTo_p_FittingMethod, 0, 0},  {&_swigt__p_FittingMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FixedDividend[] = {  {&_swigt__p_FixedDividend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FixedRateBond[] = {  {&_swigt__p_FixedRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FixedRateBondForward[] = {  {&_swigt__p_FixedRateBondForward, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FixedRateBondHelper[] = {  {&_swigt__p_FixedRateBondHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FixedRateCoupon[] = {  {&_swigt__p_FixedRateCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FlatForward[] = {  {&_swigt__p_FlatForward, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FlatHazardRate[] = {  {&_swigt__p_FlatHazardRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FlatSmileSection[] = {  {&_swigt__p_FlatSmileSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloatFloatSwap[] = {  {&_swigt__p_FloatFloatSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloatFloatSwaption[] = {  {&_swigt__p_FloatFloatSwaption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloatingRateBond[] = {  {&_swigt__p_FloatingRateBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloatingRateCoupon[] = {  {&_swigt__p_OvernightIndexedCoupon, _p_OvernightIndexedCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_CappedFlooredCoupon, _p_CappedFlooredCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_CappedFlooredIborCoupon, _p_CappedFlooredIborCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_CappedFlooredCmsSpreadCoupon, _p_CappedFlooredCmsSpreadCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_IborCoupon, _p_IborCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_CmsSpreadCoupon, _p_CmsSpreadCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_FloatingRateCoupon, 0, 0, 0},  {&_swigt__p_CappedFlooredCmsCoupon, _p_CappedFlooredCmsCouponTo_p_FloatingRateCoupon, 0, 0},  {&_swigt__p_CmsCoupon, _p_CmsCouponTo_p_FloatingRateCoupon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloatingRateCouponPricer[] = {  {&_swigt__p_FloatingRateCouponPricer, 0, 0, 0},  {&_swigt__p_IborCouponPricer, _p_IborCouponPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_BlackIborCouponPricer, _p_BlackIborCouponPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_CmsCouponPricer, _p_CmsCouponPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_AnalyticHaganPricer, _p_AnalyticHaganPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_NumericHaganPricer, _p_NumericHaganPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_LinearTsrPricer, _p_LinearTsrPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_CmsSpreadCouponPricer, _p_CmsSpreadCouponPricerTo_p_FloatingRateCouponPricer, 0, 0},  {&_swigt__p_LognormalCmsSpreadPricer, _p_LognormalCmsSpreadPricerTo_p_FloatingRateCouponPricer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Floor[] = {  {&_swigt__p_Floor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FloorTruncation[] = {  {&_swigt__p_FloorTruncation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Forward[] = {  {&_swigt__p_ForwardRateAgreement, _p_ForwardRateAgreementTo_p_Forward, 0, 0},  {&_swigt__p_Forward, 0, 0, 0},  {&_swigt__p_FixedRateBondForward, _p_FixedRateBondForwardTo_p_Forward, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ForwardEuropeanEngine[] = {  {&_swigt__p_ForwardEuropeanEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ForwardFlat[] = {  {&_swigt__p_ForwardFlat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ForwardRate[] = {  {&_swigt__p_ForwardRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ForwardRateAgreement[] = {  {&_swigt__p_ForwardRateAgreement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ForwardSpreadedTermStructure[] = {  {&_swigt__p_ForwardSpreadedTermStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ForwardVanillaOption[] = {  {&_swigt__p_ForwardVanillaOption, 0, 0, 0},  {&_swigt__p_QuantoForwardVanillaOption, _p_QuantoForwardVanillaOptionTo_p_ForwardVanillaOption, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FraRateHelper[] = {  {&_swigt__p_FraRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FractionalDividend[] = {  {&_swigt__p_FractionalDividend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Futures[] = {  {&_swigt__p_Futures, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FuturesRateHelper[] = {  {&_swigt__p_FuturesRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FxSwapRateHelper[] = {  {&_swigt__p_FxSwapRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_G2[] = {  {&_swigt__p_G2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_G2ForwardProcess[] = {  {&_swigt__p_G2ForwardProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_G2Process[] = {  {&_swigt__p_G2Process, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_G2SwaptionEngine[] = {  {&_swigt__p_G2SwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GBPLibor[] = {  {&_swigt__p_GBPLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GBPLiborON[] = {  {&_swigt__p_GBPLiborON, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GBSMRNDCalculator[] = {  {&_swigt__p_GBSMRNDCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GFunctionFactory[] = {  {&_swigt__p_GFunctionFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GJRGARCHModel[] = {  {&_swigt__p_GJRGARCHModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GJRGARCHProcess[] = {  {&_swigt__p_GJRGARCHProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GMRES[] = {  {&_swigt__p_GMRES, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GammaFunction[] = {  {&_swigt__p_GammaFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GapPayoff[] = {  {&_swigt__p_GapPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GarmanKlassSigma1[] = {  {&_swigt__p_GarmanKlassSigma1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GarmanKlassSigma3[] = {  {&_swigt__p_GarmanKlassSigma3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GarmanKlassSigma4[] = {  {&_swigt__p_GarmanKlassSigma4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GarmanKlassSigma5[] = {  {&_swigt__p_GarmanKlassSigma5, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GarmanKlassSigma6[] = {  {&_swigt__p_GarmanKlassSigma6, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GarmanKohlagenProcess[] = {  {&_swigt__p_GarmanKohlagenProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussChebyshev2ndIntegration[] = {  {&_swigt__p_GaussChebyshev2ndIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussChebyshevIntegration[] = {  {&_swigt__p_GaussChebyshevIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussGegenbauerIntegration[] = {  {&_swigt__p_GaussGegenbauerIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussHermiteIntegration[] = {  {&_swigt__p_GaussHermiteIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussHyperbolicIntegration[] = {  {&_swigt__p_GaussHyperbolicIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussJacobiIntegration[] = {  {&_swigt__p_GaussJacobiIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussKronrodAdaptive[] = {  {&_swigt__p_GaussKronrodAdaptive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussKronrodNonAdaptive[] = {  {&_swigt__p_GaussKronrodNonAdaptive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussLaguerreIntegration[] = {  {&_swigt__p_GaussLaguerreIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussLegendreIntegration[] = {  {&_swigt__p_GaussLegendreIntegration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussLobattoIntegral[] = {  {&_swigt__p_GaussLobattoIntegral, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Gaussian1dFloatFloatSwaptionEngine[] = {  {&_swigt__p_Gaussian1dFloatFloatSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Gaussian1dJamshidianSwaptionEngine[] = {  {&_swigt__p_Gaussian1dJamshidianSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Gaussian1dModel[] = {  {&_swigt__p_Gaussian1dModel, 0, 0, 0},  {&_swigt__p_Gsr, _p_GsrTo_p_Gaussian1dModel, 0, 0},  {&_swigt__p_MarkovFunctional, _p_MarkovFunctionalTo_p_Gaussian1dModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Gaussian1dNonstandardSwaptionEngine[] = {  {&_swigt__p_Gaussian1dNonstandardSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Gaussian1dSwaptionEngine[] = {  {&_swigt__p_Gaussian1dSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussianLowDiscrepancySequenceGenerator[] = {  {&_swigt__p_GaussianLowDiscrepancySequenceGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussianMultiPathGenerator[] = {  {&_swigt__p_GaussianMultiPathGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussianRandomGenerator[] = {  {&_swigt__p_GaussianRandomGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussianRandomSequenceGenerator[] = {  {&_swigt__p_GaussianRandomSequenceGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GaussianSimulatedAnnealing[] = {  {&_swigt__p_GaussianSimulatedAnnealing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GbpLiborSwapIsdaFix[] = {  {&_swigt__p_GbpLiborSwapIsdaFix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GeneralizedBlackScholesProcess[] = {  {&_swigt__p_GeneralizedBlackScholesProcess, 0, 0, 0},  {&_swigt__p_BlackScholesProcess, _p_BlackScholesProcessTo_p_GeneralizedBlackScholesProcess, 0, 0},  {&_swigt__p_BlackScholesMertonProcess, _p_BlackScholesMertonProcessTo_p_GeneralizedBlackScholesProcess, 0, 0},  {&_swigt__p_BlackProcess, _p_BlackProcessTo_p_GeneralizedBlackScholesProcess, 0, 0},  {&_swigt__p_GarmanKohlagenProcess, _p_GarmanKohlagenProcessTo_p_GeneralizedBlackScholesProcess, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GenericSequenceStatisticsT_IncrementalStatistics_t[] = {  {&_swigt__p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GenericSequenceStatisticsT_RiskStatistics_t[] = {  {&_swigt__p_GenericSequenceStatisticsT_RiskStatistics_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GenericSequenceStatisticsT_Statistics_t[] = {  {&_swigt__p_GenericSequenceStatisticsT_Statistics_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GeometricBrownianMotionProcess[] = {  {&_swigt__p_GeometricBrownianMotionProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GlobalLinearSimpleZeroCurve[] = {  {&_swigt__p_GlobalLinearSimpleZeroCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Glued1dMesher[] = {  {&_swigt__p_Glued1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Gsr[] = {  {&_swigt__p_Gsr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GsrProcess[] = {  {&_swigt__p_GsrProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HaltonRsg[] = {  {&_swigt__p_HaltonRsg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_BlackVolTermStructure_t[] = {  {&_swigt__p_HandleT_BlackVolTermStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_BlackVolTermStructure_t, _p_RelinkableHandleT_BlackVolTermStructure_tTo_p_HandleT_BlackVolTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_CalibratedModel_t[] = {  {&_swigt__p_HandleT_CalibratedModel_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_CalibratedModel_t, _p_RelinkableHandleT_CalibratedModel_tTo_p_HandleT_CalibratedModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_CapFloorTermVolatilityStructure_t[] = {  {&_swigt__p_HandleT_CapFloorTermVolatilityStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, _p_RelinkableHandleT_CapFloorTermVolatilityStructure_tTo_p_HandleT_CapFloorTermVolatilityStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_DefaultProbabilityTermStructure_t[] = {  {&_swigt__p_HandleT_DefaultProbabilityTermStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_DefaultProbabilityTermStructure_t, _p_RelinkableHandleT_DefaultProbabilityTermStructure_tTo_p_HandleT_DefaultProbabilityTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_DeltaVolQuote_t[] = {  {&_swigt__p_HandleT_DeltaVolQuote_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_DeltaVolQuote_t, _p_RelinkableHandleT_DeltaVolQuote_tTo_p_HandleT_DeltaVolQuote_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_HestonModel_t[] = {  {&_swigt__p_HandleT_HestonModel_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_LocalVolTermStructure_t[] = {  {&_swigt__p_HandleT_LocalVolTermStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_LocalVolTermStructure_t, _p_RelinkableHandleT_LocalVolTermStructure_tTo_p_HandleT_LocalVolTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_OptionletVolatilityStructure_t[] = {  {&_swigt__p_HandleT_OptionletVolatilityStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_OptionletVolatilityStructure_t, _p_RelinkableHandleT_OptionletVolatilityStructure_tTo_p_HandleT_OptionletVolatilityStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_Quote_t[] = {  {&_swigt__p_HandleT_Quote_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_Quote_t, _p_RelinkableHandleT_Quote_tTo_p_HandleT_Quote_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_ShortRateModel_t[] = {  {&_swigt__p_HandleT_ShortRateModel_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_ShortRateModel_t, _p_RelinkableHandleT_ShortRateModel_tTo_p_HandleT_ShortRateModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_SwaptionVolatilityStructure_t[] = {  {&_swigt__p_HandleT_SwaptionVolatilityStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_SwaptionVolatilityStructure_t, _p_RelinkableHandleT_SwaptionVolatilityStructure_tTo_p_HandleT_SwaptionVolatilityStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_YieldTermStructure_t[] = {  {&_swigt__p_HandleT_YieldTermStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_YieldTermStructure_t, _p_RelinkableHandleT_YieldTermStructure_tTo_p_HandleT_YieldTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_YoYInflationTermStructure_t[] = {  {&_swigt__p_HandleT_YoYInflationTermStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_YoYInflationTermStructure_t, _p_RelinkableHandleT_YoYInflationTermStructure_tTo_p_HandleT_YoYInflationTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_YoYOptionletVolatilitySurface_t[] = {  {&_swigt__p_HandleT_YoYOptionletVolatilitySurface_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, _p_RelinkableHandleT_YoYOptionletVolatilitySurface_tTo_p_HandleT_YoYOptionletVolatilitySurface_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HandleT_ZeroInflationTermStructure_t[] = {  {&_swigt__p_HandleT_ZeroInflationTermStructure_t, 0, 0, 0},  {&_swigt__p_RelinkableHandleT_ZeroInflationTermStructure_t, _p_RelinkableHandleT_ZeroInflationTermStructure_tTo_p_HandleT_ZeroInflationTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HazardRate[] = {  {&_swigt__p_HazardRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonBlackVolSurface[] = {  {&_swigt__p_HestonBlackVolSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonModel[] = {  {&_swigt__p_BatesModel, _p_BatesModelTo_p_HestonModel, 0, 0},  {&_swigt__p_HestonModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonModelHelper[] = {  {&_swigt__p_HestonModelHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonProcess[] = {  {&_swigt__p_HestonProcess, 0, 0, 0},  {&_swigt__p_BatesProcess, _p_BatesProcessTo_p_HestonProcess, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonRNDCalculator[] = {  {&_swigt__p_HestonRNDCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonSLVFDMModel[] = {  {&_swigt__p_HestonSLVFDMModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonSLVFokkerPlanckFdmParams[] = {  {&_swigt__p_HestonSLVFokkerPlanckFdmParams, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonSLVMCModel[] = {  {&_swigt__p_HestonSLVMCModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HestonSLVProcess[] = {  {&_swigt__p_HestonSLVProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HimalayaOption[] = {  {&_swigt__p_HimalayaOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HullWhite[] = {  {&_swigt__p_HullWhite, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HullWhiteForwardProcess[] = {  {&_swigt__p_HullWhiteForwardProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HullWhiteProcess[] = {  {&_swigt__p_HullWhiteProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HundsdorferScheme[] = {  {&_swigt__p_HundsdorferScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IMM[] = {  {&_swigt__p_IMM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IborCoupon[] = {  {&_swigt__p_IborCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IborCouponPricer[] = {  {&_swigt__p_IborCouponPricer, 0, 0, 0},  {&_swigt__p_BlackIborCouponPricer, _p_BlackIborCouponPricerTo_p_IborCouponPricer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IborIndex[] = {  {&_swigt__p_Wibor, _p_WiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365, _p_Euribor365To_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor, _p_EURLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_1Y, _p_Euribor365_1YTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor3M, _p_Euribor3MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor3M, _p_EURLibor3MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor3M, _p_Bibor3MTo_p_IborIndex, 0, 0},  {&_swigt__p_Pribor, _p_PriborTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor8M, _p_Euribor8MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor8M, _p_EURLibor8MTo_p_IborIndex, 0, 0},  {&_swigt__p_GBPLibor, _p_GBPLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw2M, _p_Bbsw2MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_4M, _p_Euribor365_4MTo_p_IborIndex, 0, 0},  {&_swigt__p_Aonia, _p_AoniaTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_9M, _p_Euribor365_9MTo_p_IborIndex, 0, 0},  {&_swigt__p_BiborSW, _p_BiborSWTo_p_IborIndex, 0, 0},  {&_swigt__p_EuriborSW, _p_EuriborSWTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLiborSW, _p_EURLiborSWTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm2M, _p_Bkbm2MTo_p_IborIndex, 0, 0},  {&_swigt__p_Robor, _p_RoborTo_p_IborIndex, 0, 0},  {&_swigt__p_Sonia, _p_SoniaTo_p_IborIndex, 0, 0},  {&_swigt__p_FedFunds, _p_FedFundsTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor3W, _p_Euribor3WTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor1M, _p_Bibor1MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor1M, _p_Euribor1MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor1M, _p_EURLibor1MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor6M, _p_Euribor6MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor6M, _p_Bibor6MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor6M, _p_EURLibor6MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw5M, _p_Bbsw5MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_2M, _p_Euribor365_2MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_7M, _p_Euribor365_7MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw, _p_BbswTo_p_IborIndex, 0, 0},  {&_swigt__p_NZDLibor, _p_NZDLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Cdor, _p_CdorTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_10M, _p_Euribor365_10MTo_p_IborIndex, 0, 0},  {&_swigt__p_Zibor, _p_ZiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm5M, _p_Bkbm5MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor11M, _p_Euribor11MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor11M, _p_EURLibor11MTo_p_IborIndex, 0, 0},  {&_swigt__p_DailyTenorLibor, _p_DailyTenorLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_TRLibor, _p_TRLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor1Y, _p_Euribor1YTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor1Y, _p_Bibor1YTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor1Y, _p_EURLibor1YTo_p_IborIndex, 0, 0},  {&_swigt__p_USDLiborON, _p_USDLiborONTo_p_IborIndex, 0, 0},  {&_swigt__p_GBPLiborON, _p_GBPLiborONTo_p_IborIndex, 0, 0},  {&_swigt__p_CADLiborON, _p_CADLiborONTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_2W, _p_Euribor365_2WTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor4M, _p_Euribor4MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor4M, _p_EURLibor4MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor9M, _p_Euribor9MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor9M, _p_Bibor9MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor9M, _p_EURLibor9MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw3M, _p_Bbsw3MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_5M, _p_Euribor365_5MTo_p_IborIndex, 0, 0},  {&_swigt__p_DKKLibor, _p_DKKLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_SEKLibor, _p_SEKLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm3M, _p_Bkbm3MTo_p_IborIndex, 0, 0},  {&_swigt__p_Eonia, _p_EoniaTo_p_IborIndex, 0, 0},  {&_swigt__p_THBFIX, _p_THBFIXTo_p_IborIndex, 0, 0},  {&_swigt__p_CHFLibor, _p_CHFLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor, _p_BiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor, _p_EuriborTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor2M, _p_EURLibor2MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bibor2M, _p_Bibor2MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor2M, _p_Euribor2MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor7M, _p_EURLibor7MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw1M, _p_Bbsw1MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor7M, _p_Euribor7MTo_p_IborIndex, 0, 0},  {&_swigt__p_Tibor, _p_TiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw6M, _p_Bbsw6MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_3M, _p_Euribor365_3MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_8M, _p_Euribor365_8MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm1M, _p_Bkbm1MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_11M, _p_Euribor365_11MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm6M, _p_Bkbm6MTo_p_IborIndex, 0, 0},  {&_swigt__p_Libor, _p_LiborTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor2W, _p_EURLibor2WTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor2W, _p_Euribor2WTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_SW, _p_Euribor365_SWTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_3W, _p_Euribor365_3WTo_p_IborIndex, 0, 0},  {&_swigt__p_Sofr, _p_SofrTo_p_IborIndex, 0, 0},  {&_swigt__p_OvernightIndex, _p_OvernightIndexTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor5M, _p_EURLibor5MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor5M, _p_Euribor5MTo_p_IborIndex, 0, 0},  {&_swigt__p_Shibor, _p_ShiborTo_p_IborIndex, 0, 0},  {&_swigt__p_Jibar, _p_JibarTo_p_IborIndex, 0, 0},  {&_swigt__p_Bbsw4M, _p_Bbsw4MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor365_1M, _p_Euribor365_1MTo_p_IborIndex, 0, 0},  {&_swigt__p_JPYLibor, _p_JPYLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_IborIndex, 0, 0, 0},  {&_swigt__p_Euribor365_6M, _p_Euribor365_6MTo_p_IborIndex, 0, 0},  {&_swigt__p_Mosprime, _p_MosprimeTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm4M, _p_Bkbm4MTo_p_IborIndex, 0, 0},  {&_swigt__p_EURLibor10M, _p_EURLibor10MTo_p_IborIndex, 0, 0},  {&_swigt__p_Euribor10M, _p_Euribor10MTo_p_IborIndex, 0, 0},  {&_swigt__p_Bkbm, _p_BkbmTo_p_IborIndex, 0, 0},  {&_swigt__p_Nzocr, _p_NzocrTo_p_IborIndex, 0, 0},  {&_swigt__p_CADLibor, _p_CADLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_AUDLibor, _p_AUDLiborTo_p_IborIndex, 0, 0},  {&_swigt__p_USDLibor, _p_USDLiborTo_p_IborIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ImplicitEulerScheme[] = {  {&_swigt__p_ImplicitEulerScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ImpliedTermStructure[] = {  {&_swigt__p_ImpliedTermStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IncrementalStatistics[] = {  {&_swigt__p_IncrementalStatistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Index[] = {  {&_swigt__p_Wibor, _p_WiborTo_p_Index, 0, 0},  {&_swigt__p_YYEUHICPr, _p_YYEUHICPrTo_p_Index, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixA, _p_EuriborSwapIsdaFixATo_p_Index, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixA, _p_EurLiborSwapIsdaFixATo_p_Index, 0, 0},  {&_swigt__p_Euribor365, _p_Euribor365To_p_Index, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixB, _p_EurLiborSwapIsdaFixBTo_p_Index, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixB, _p_EuriborSwapIsdaFixBTo_p_Index, 0, 0},  {&_swigt__p_EURLibor, _p_EURLiborTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_1Y, _p_Euribor365_1YTo_p_Index, 0, 0},  {&_swigt__p_Bibor3M, _p_Bibor3MTo_p_Index, 0, 0},  {&_swigt__p_Euribor3M, _p_Euribor3MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor3M, _p_EURLibor3MTo_p_Index, 0, 0},  {&_swigt__p_ZACPI, _p_ZACPITo_p_Index, 0, 0},  {&_swigt__p_Pribor, _p_PriborTo_p_Index, 0, 0},  {&_swigt__p_Euribor8M, _p_Euribor8MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor8M, _p_EURLibor8MTo_p_Index, 0, 0},  {&_swigt__p_GBPLibor, _p_GBPLiborTo_p_Index, 0, 0},  {&_swigt__p_Bbsw2M, _p_Bbsw2MTo_p_Index, 0, 0},  {&_swigt__p_YYUKRPIr, _p_YYUKRPIrTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_4M, _p_Euribor365_4MTo_p_Index, 0, 0},  {&_swigt__p_Aonia, _p_AoniaTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_9M, _p_Euribor365_9MTo_p_Index, 0, 0},  {&_swigt__p_BiborSW, _p_BiborSWTo_p_Index, 0, 0},  {&_swigt__p_EuriborSW, _p_EuriborSWTo_p_Index, 0, 0},  {&_swigt__p_EURLiborSW, _p_EURLiborSWTo_p_Index, 0, 0},  {&_swigt__p_Bkbm2M, _p_Bkbm2MTo_p_Index, 0, 0},  {&_swigt__p_Robor, _p_RoborTo_p_Index, 0, 0},  {&_swigt__p_InterestRateIndex, _p_InterestRateIndexTo_p_Index, 0, 0},  {&_swigt__p_Sonia, _p_SoniaTo_p_Index, 0, 0},  {&_swigt__p_FedFunds, _p_FedFundsTo_p_Index, 0, 0},  {&_swigt__p_GbpLiborSwapIsdaFix, _p_GbpLiborSwapIsdaFixTo_p_Index, 0, 0},  {&_swigt__p_ChfLiborSwapIsdaFix, _p_ChfLiborSwapIsdaFixTo_p_Index, 0, 0},  {&_swigt__p_Euribor3W, _p_Euribor3WTo_p_Index, 0, 0},  {&_swigt__p_YYUSCPIr, _p_YYUSCPIrTo_p_Index, 0, 0},  {&_swigt__p_Euribor1M, _p_Euribor1MTo_p_Index, 0, 0},  {&_swigt__p_Bibor1M, _p_Bibor1MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor1M, _p_EURLibor1MTo_p_Index, 0, 0},  {&_swigt__p_Euribor6M, _p_Euribor6MTo_p_Index, 0, 0},  {&_swigt__p_Bibor6M, _p_Bibor6MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor6M, _p_EURLibor6MTo_p_Index, 0, 0},  {&_swigt__p_Bbsw5M, _p_Bbsw5MTo_p_Index, 0, 0},  {&_swigt__p_Index, 0, 0, 0},  {&_swigt__p_Euribor365_2M, _p_Euribor365_2MTo_p_Index, 0, 0},  {&_swigt__p_EuriborSwapIfrFix, _p_EuriborSwapIfrFixTo_p_Index, 0, 0},  {&_swigt__p_EurLiborSwapIfrFix, _p_EurLiborSwapIfrFixTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_7M, _p_Euribor365_7MTo_p_Index, 0, 0},  {&_swigt__p_Bbsw, _p_BbswTo_p_Index, 0, 0},  {&_swigt__p_YoYInflationIndex, _p_YoYInflationIndexTo_p_Index, 0, 0},  {&_swigt__p_ZeroInflationIndex, _p_ZeroInflationIndexTo_p_Index, 0, 0},  {&_swigt__p_InflationIndex, _p_InflationIndexTo_p_Index, 0, 0},  {&_swigt__p_NZDLibor, _p_NZDLiborTo_p_Index, 0, 0},  {&_swigt__p_Cdor, _p_CdorTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_10M, _p_Euribor365_10MTo_p_Index, 0, 0},  {&_swigt__p_Zibor, _p_ZiborTo_p_Index, 0, 0},  {&_swigt__p_Bkbm5M, _p_Bkbm5MTo_p_Index, 0, 0},  {&_swigt__p_Euribor11M, _p_Euribor11MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor11M, _p_EURLibor11MTo_p_Index, 0, 0},  {&_swigt__p_TRLibor, _p_TRLiborTo_p_Index, 0, 0},  {&_swigt__p_DailyTenorLibor, _p_DailyTenorLiborTo_p_Index, 0, 0},  {&_swigt__p_EURLibor1Y, _p_EURLibor1YTo_p_Index, 0, 0},  {&_swigt__p_Bibor1Y, _p_Bibor1YTo_p_Index, 0, 0},  {&_swigt__p_Euribor1Y, _p_Euribor1YTo_p_Index, 0, 0},  {&_swigt__p_YYEUHICPXT, _p_YYEUHICPXTTo_p_Index, 0, 0},  {&_swigt__p_EUHICPXT, _p_EUHICPXTTo_p_Index, 0, 0},  {&_swigt__p_CADLiborON, _p_CADLiborONTo_p_Index, 0, 0},  {&_swigt__p_GBPLiborON, _p_GBPLiborONTo_p_Index, 0, 0},  {&_swigt__p_USDLiborON, _p_USDLiborONTo_p_Index, 0, 0},  {&_swigt__p_YYUSCPI, _p_YYUSCPITo_p_Index, 0, 0},  {&_swigt__p_YYZACPIr, _p_YYZACPIrTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_2W, _p_Euribor365_2WTo_p_Index, 0, 0},  {&_swigt__p_YYFRHICPr, _p_YYFRHICPrTo_p_Index, 0, 0},  {&_swigt__p_EURLibor4M, _p_EURLibor4MTo_p_Index, 0, 0},  {&_swigt__p_Euribor4M, _p_Euribor4MTo_p_Index, 0, 0},  {&_swigt__p_YYEUHICP, _p_YYEUHICPTo_p_Index, 0, 0},  {&_swigt__p_EUHICP, _p_EUHICPTo_p_Index, 0, 0},  {&_swigt__p_EURLibor9M, _p_EURLibor9MTo_p_Index, 0, 0},  {&_swigt__p_Bbsw3M, _p_Bbsw3MTo_p_Index, 0, 0},  {&_swigt__p_Bibor9M, _p_Bibor9MTo_p_Index, 0, 0},  {&_swigt__p_Euribor9M, _p_Euribor9MTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_5M, _p_Euribor365_5MTo_p_Index, 0, 0},  {&_swigt__p_SEKLibor, _p_SEKLiborTo_p_Index, 0, 0},  {&_swigt__p_DKKLibor, _p_DKKLiborTo_p_Index, 0, 0},  {&_swigt__p_Bkbm3M, _p_Bkbm3MTo_p_Index, 0, 0},  {&_swigt__p_YYUKRPI, _p_YYUKRPITo_p_Index, 0, 0},  {&_swigt__p_Eonia, _p_EoniaTo_p_Index, 0, 0},  {&_swigt__p_THBFIX, _p_THBFIXTo_p_Index, 0, 0},  {&_swigt__p_SwapIndex, _p_SwapIndexTo_p_Index, 0, 0},  {&_swigt__p_OvernightIndexedSwapIndex, _p_OvernightIndexedSwapIndexTo_p_Index, 0, 0},  {&_swigt__p_Bibor, _p_BiborTo_p_Index, 0, 0},  {&_swigt__p_CHFLibor, _p_CHFLiborTo_p_Index, 0, 0},  {&_swigt__p_USCPI, _p_USCPITo_p_Index, 0, 0},  {&_swigt__p_Euribor, _p_EuriborTo_p_Index, 0, 0},  {&_swigt__p_EURLibor2M, _p_EURLibor2MTo_p_Index, 0, 0},  {&_swigt__p_Bibor2M, _p_Bibor2MTo_p_Index, 0, 0},  {&_swigt__p_Euribor2M, _p_Euribor2MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor7M, _p_EURLibor7MTo_p_Index, 0, 0},  {&_swigt__p_Bbsw1M, _p_Bbsw1MTo_p_Index, 0, 0},  {&_swigt__p_Euribor7M, _p_Euribor7MTo_p_Index, 0, 0},  {&_swigt__p_Tibor, _p_TiborTo_p_Index, 0, 0},  {&_swigt__p_Bbsw6M, _p_Bbsw6MTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_3M, _p_Euribor365_3MTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_8M, _p_Euribor365_8MTo_p_Index, 0, 0},  {&_swigt__p_Bkbm1M, _p_Bkbm1MTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_11M, _p_Euribor365_11MTo_p_Index, 0, 0},  {&_swigt__p_Bkbm6M, _p_Bkbm6MTo_p_Index, 0, 0},  {&_swigt__p_Libor, _p_LiborTo_p_Index, 0, 0},  {&_swigt__p_YYFRHICP, _p_YYFRHICPTo_p_Index, 0, 0},  {&_swigt__p_FRHICP, _p_FRHICPTo_p_Index, 0, 0},  {&_swigt__p_EURLibor2W, _p_EURLibor2WTo_p_Index, 0, 0},  {&_swigt__p_Euribor2W, _p_Euribor2WTo_p_Index, 0, 0},  {&_swigt__p_UKRPI, _p_UKRPITo_p_Index, 0, 0},  {&_swigt__p_Euribor365_SW, _p_Euribor365_SWTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_3W, _p_Euribor365_3WTo_p_Index, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixAm, _p_UsdLiborSwapIsdaFixAmTo_p_Index, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixAm, _p_JpyLiborSwapIsdaFixAmTo_p_Index, 0, 0},  {&_swigt__p_Sofr, _p_SofrTo_p_Index, 0, 0},  {&_swigt__p_OvernightIndex, _p_OvernightIndexTo_p_Index, 0, 0},  {&_swigt__p_YYZACPI, _p_YYZACPITo_p_Index, 0, 0},  {&_swigt__p_EURLibor5M, _p_EURLibor5MTo_p_Index, 0, 0},  {&_swigt__p_Euribor5M, _p_Euribor5MTo_p_Index, 0, 0},  {&_swigt__p_Shibor, _p_ShiborTo_p_Index, 0, 0},  {&_swigt__p_Jibar, _p_JibarTo_p_Index, 0, 0},  {&_swigt__p_SwapSpreadIndex, _p_SwapSpreadIndexTo_p_Index, 0, 0},  {&_swigt__p_Bbsw4M, _p_Bbsw4MTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_1M, _p_Euribor365_1MTo_p_Index, 0, 0},  {&_swigt__p_JPYLibor, _p_JPYLiborTo_p_Index, 0, 0},  {&_swigt__p_IborIndex, _p_IborIndexTo_p_Index, 0, 0},  {&_swigt__p_Euribor365_6M, _p_Euribor365_6MTo_p_Index, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixPm, _p_UsdLiborSwapIsdaFixPmTo_p_Index, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixPm, _p_JpyLiborSwapIsdaFixPmTo_p_Index, 0, 0},  {&_swigt__p_AUCPI, _p_AUCPITo_p_Index, 0, 0},  {&_swigt__p_Mosprime, _p_MosprimeTo_p_Index, 0, 0},  {&_swigt__p_Bkbm4M, _p_Bkbm4MTo_p_Index, 0, 0},  {&_swigt__p_EURLibor10M, _p_EURLibor10MTo_p_Index, 0, 0},  {&_swigt__p_Euribor10M, _p_Euribor10MTo_p_Index, 0, 0},  {&_swigt__p_Bkbm, _p_BkbmTo_p_Index, 0, 0},  {&_swigt__p_Nzocr, _p_NzocrTo_p_Index, 0, 0},  {&_swigt__p_CADLibor, _p_CADLiborTo_p_Index, 0, 0},  {&_swigt__p_AUDLibor, _p_AUDLiborTo_p_Index, 0, 0},  {&_swigt__p_USDLibor, _p_USDLiborTo_p_Index, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IndexManager[] = {  {&_swigt__p_IndexManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IndexedCashFlow[] = {  {&_swigt__p_IndexedCashFlow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InflationCoupon[] = {  {&_swigt__p_InflationCoupon, 0, 0, 0},  {&_swigt__p_CPICoupon, _p_CPICouponTo_p_InflationCoupon, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InflationIndex[] = {  {&_swigt__p_YYUKRPIr, _p_YYUKRPIrTo_p_InflationIndex, 0, 0},  {&_swigt__p_USCPI, _p_USCPITo_p_InflationIndex, 0, 0},  {&_swigt__p_YoYInflationIndex, _p_YoYInflationIndexTo_p_InflationIndex, 0, 0},  {&_swigt__p_EUHICPXT, _p_EUHICPXTTo_p_InflationIndex, 0, 0},  {&_swigt__p_ZeroInflationIndex, _p_ZeroInflationIndexTo_p_InflationIndex, 0, 0},  {&_swigt__p_InflationIndex, 0, 0, 0},  {&_swigt__p_YYUSCPI, _p_YYUSCPITo_p_InflationIndex, 0, 0},  {&_swigt__p_YYEUHICPXT, _p_YYEUHICPXTTo_p_InflationIndex, 0, 0},  {&_swigt__p_ZACPI, _p_ZACPITo_p_InflationIndex, 0, 0},  {&_swigt__p_YYZACPIr, _p_YYZACPIrTo_p_InflationIndex, 0, 0},  {&_swigt__p_AUCPI, _p_AUCPITo_p_InflationIndex, 0, 0},  {&_swigt__p_YYEUHICP, _p_YYEUHICPTo_p_InflationIndex, 0, 0},  {&_swigt__p_EUHICP, _p_EUHICPTo_p_InflationIndex, 0, 0},  {&_swigt__p_YYZACPI, _p_YYZACPITo_p_InflationIndex, 0, 0},  {&_swigt__p_UKRPI, _p_UKRPITo_p_InflationIndex, 0, 0},  {&_swigt__p_YYUKRPI, _p_YYUKRPITo_p_InflationIndex, 0, 0},  {&_swigt__p_YYFRHICPr, _p_YYFRHICPrTo_p_InflationIndex, 0, 0},  {&_swigt__p_YYEUHICPr, _p_YYEUHICPrTo_p_InflationIndex, 0, 0},  {&_swigt__p_FRHICP, _p_FRHICPTo_p_InflationIndex, 0, 0},  {&_swigt__p_YYUSCPIr, _p_YYUSCPIrTo_p_InflationIndex, 0, 0},  {&_swigt__p_YYFRHICP, _p_YYFRHICPTo_p_InflationIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InflationTermStructure[] = {  {&_swigt__p_PiecewiseZeroInflationCurveT_Linear_t, _p_PiecewiseZeroInflationCurveT_Linear_tTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_PiecewiseYoYInflationCurveT_Linear_t, _p_PiecewiseYoYInflationCurveT_Linear_tTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroInflationCurveT_Linear_t, _p_InterpolatedZeroInflationCurveT_Linear_tTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_InterpolatedYoYInflationCurveT_Linear_t, _p_InterpolatedYoYInflationCurveT_Linear_tTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_InflationTermStructure, 0, 0, 0},  {&_swigt__p_YoYInflationTermStructure, _p_YoYInflationTermStructureTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_ZeroInflationTermStructure, _p_ZeroInflationTermStructureTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_YoYCapFloorTermPriceSurface, _p_YoYCapFloorTermPriceSurfaceTo_p_InflationTermStructure, 0, 0},  {&_swigt__p_YoYInflationCapFloorTermPriceSurface, _p_YoYInflationCapFloorTermPriceSurfaceTo_p_InflationTermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Instrument[] = {  {&_swigt__p_Collar, _p_CollarTo_p_Instrument, 0, 0},  {&_swigt__p_MultiAssetOption, _p_MultiAssetOptionTo_p_Instrument, 0, 0},  {&_swigt__p_BarrierOption, _p_BarrierOptionTo_p_Instrument, 0, 0},  {&_swigt__p_DividendBarrierOption, _p_DividendBarrierOptionTo_p_Instrument, 0, 0},  {&_swigt__p_ContinuousAveragingAsianOption, _p_ContinuousAveragingAsianOptionTo_p_Instrument, 0, 0},  {&_swigt__p_EuropeanOption, _p_EuropeanOptionTo_p_Instrument, 0, 0},  {&_swigt__p_EverestOption, _p_EverestOptionTo_p_Instrument, 0, 0},  {&_swigt__p_BasketOption, _p_BasketOptionTo_p_Instrument, 0, 0},  {&_swigt__p_SpreadOption, _p_SpreadOptionTo_p_Instrument, 0, 0},  {&_swigt__p_QuantoDoubleBarrierOption, _p_QuantoDoubleBarrierOptionTo_p_Instrument, 0, 0},  {&_swigt__p_DoubleBarrierOption, _p_DoubleBarrierOptionTo_p_Instrument, 0, 0},  {&_swigt__p_DiscreteAveragingAsianOption, _p_DiscreteAveragingAsianOptionTo_p_Instrument, 0, 0},  {&_swigt__p_OneAssetOption, _p_OneAssetOptionTo_p_Instrument, 0, 0},  {&_swigt__p_AssetSwap, _p_AssetSwapTo_p_Instrument, 0, 0},  {&_swigt__p_OvernightIndexedSwap, _p_OvernightIndexedSwapTo_p_Instrument, 0, 0},  {&_swigt__p_YearOnYearInflationSwap, _p_YearOnYearInflationSwapTo_p_Instrument, 0, 0},  {&_swigt__p_ZeroCouponInflationSwap, _p_ZeroCouponInflationSwapTo_p_Instrument, 0, 0},  {&_swigt__p_VanillaSwap, _p_VanillaSwapTo_p_Instrument, 0, 0},  {&_swigt__p_YoYInflationFloor, _p_YoYInflationFloorTo_p_Instrument, 0, 0},  {&_swigt__p_Bond, _p_BondTo_p_Instrument, 0, 0},  {&_swigt__p_CapFloor, _p_CapFloorTo_p_Instrument, 0, 0},  {&_swigt__p_YoYInflationCapFloor, _p_YoYInflationCapFloorTo_p_Instrument, 0, 0},  {&_swigt__p_Swap, _p_SwapTo_p_Instrument, 0, 0},  {&_swigt__p_HimalayaOption, _p_HimalayaOptionTo_p_Instrument, 0, 0},  {&_swigt__p_VanillaOption, _p_VanillaOptionTo_p_Instrument, 0, 0},  {&_swigt__p_VanillaSwingOption, _p_VanillaSwingOptionTo_p_Instrument, 0, 0},  {&_swigt__p_DividendVanillaOption, _p_DividendVanillaOptionTo_p_Instrument, 0, 0},  {&_swigt__p_QuantoForwardVanillaOption, _p_QuantoForwardVanillaOptionTo_p_Instrument, 0, 0},  {&_swigt__p_QuantoVanillaOption, _p_QuantoVanillaOptionTo_p_Instrument, 0, 0},  {&_swigt__p_ForwardVanillaOption, _p_ForwardVanillaOptionTo_p_Instrument, 0, 0},  {&_swigt__p_CdsOption, _p_CdsOptionTo_p_Instrument, 0, 0},  {&_swigt__p_Option, _p_OptionTo_p_Instrument, 0, 0},  {&_swigt__p_ForwardRateAgreement, _p_ForwardRateAgreementTo_p_Instrument, 0, 0},  {&_swigt__p_ZeroCouponBond, _p_ZeroCouponBondTo_p_Instrument, 0, 0},  {&_swigt__p_CallableZeroCouponBond, _p_CallableZeroCouponBondTo_p_Instrument, 0, 0},  {&_swigt__p_ConvertibleZeroCouponBond, _p_ConvertibleZeroCouponBondTo_p_Instrument, 0, 0},  {&_swigt__p_ConvertibleFixedCouponBond, _p_ConvertibleFixedCouponBondTo_p_Instrument, 0, 0},  {&_swigt__p_Floor, _p_FloorTo_p_Instrument, 0, 0},  {&_swigt__p_Stock, _p_StockTo_p_Instrument, 0, 0},  {&_swigt__p_Swaption, _p_SwaptionTo_p_Instrument, 0, 0},  {&_swigt__p_NonstandardSwaption, _p_NonstandardSwaptionTo_p_Instrument, 0, 0},  {&_swigt__p_FloatFloatSwaption, _p_FloatFloatSwaptionTo_p_Instrument, 0, 0},  {&_swigt__p_Instrument, 0, 0, 0},  {&_swigt__p_CompositeInstrument, _p_CompositeInstrumentTo_p_Instrument, 0, 0},  {&_swigt__p_YoYInflationCollar, _p_YoYInflationCollarTo_p_Instrument, 0, 0},  {&_swigt__p_CallableBond, _p_CallableBondTo_p_Instrument, 0, 0},  {&_swigt__p_YoYInflationCap, _p_YoYInflationCapTo_p_Instrument, 0, 0},  {&_swigt__p_CallableFixedRateBond, _p_CallableFixedRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_ConvertibleFloatingRateBond, _p_ConvertibleFloatingRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_CmsRateBond, _p_CmsRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_FloatingRateBond, _p_FloatingRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_AmortizingFloatingRateBond, _p_AmortizingFloatingRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_AmortizingFixedRateBond, _p_AmortizingFixedRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_FixedRateBond, _p_FixedRateBondTo_p_Instrument, 0, 0},  {&_swigt__p_NonstandardSwap, _p_NonstandardSwapTo_p_Instrument, 0, 0},  {&_swigt__p_CreditDefaultSwap, _p_CreditDefaultSwapTo_p_Instrument, 0, 0},  {&_swigt__p_Cap, _p_CapTo_p_Instrument, 0, 0},  {&_swigt__p_Forward, _p_ForwardTo_p_Instrument, 0, 0},  {&_swigt__p_FixedRateBondForward, _p_FixedRateBondForwardTo_p_Instrument, 0, 0},  {&_swigt__p_CPIBond, _p_CPIBondTo_p_Instrument, 0, 0},  {&_swigt__p_FloatFloatSwap, _p_FloatFloatSwapTo_p_Instrument, 0, 0},  {&_swigt__p_CPISwap, _p_CPISwapTo_p_Instrument, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntegralCdsEngine[] = {  {&_swigt__p_IntegralCdsEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntegralEngine[] = {  {&_swigt__p_IntegralEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Integration[] = {  {&_swigt__p_Integration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterestRate[] = {  {&_swigt__p_InterestRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterestRateIndex[] = {  {&_swigt__p_Wibor, _p_WiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixA, _p_EuriborSwapIsdaFixATo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixA, _p_EurLiborSwapIsdaFixATo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365, _p_Euribor365To_p_InterestRateIndex, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixB, _p_EurLiborSwapIsdaFixBTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixB, _p_EuriborSwapIsdaFixBTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor, _p_EURLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_1Y, _p_Euribor365_1YTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor3M, _p_Euribor3MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor3M, _p_Bibor3MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor3M, _p_EURLibor3MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Pribor, _p_PriborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor8M, _p_Euribor8MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor8M, _p_EURLibor8MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_GBPLibor, _p_GBPLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw2M, _p_Bbsw2MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_4M, _p_Euribor365_4MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Aonia, _p_AoniaTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_9M, _p_Euribor365_9MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_BiborSW, _p_BiborSWTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EuriborSW, _p_EuriborSWTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLiborSW, _p_EURLiborSWTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm2M, _p_Bkbm2MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Robor, _p_RoborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_InterestRateIndex, 0, 0, 0},  {&_swigt__p_Sonia, _p_SoniaTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_FedFunds, _p_FedFundsTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_GbpLiborSwapIsdaFix, _p_GbpLiborSwapIsdaFixTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_ChfLiborSwapIsdaFix, _p_ChfLiborSwapIsdaFixTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor3W, _p_Euribor3WTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor1M, _p_Euribor1MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor1M, _p_Bibor1MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor1M, _p_EURLibor1MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor6M, _p_Euribor6MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor6M, _p_Bibor6MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor6M, _p_EURLibor6MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw5M, _p_Bbsw5MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_2M, _p_Euribor365_2MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EuriborSwapIfrFix, _p_EuriborSwapIfrFixTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EurLiborSwapIfrFix, _p_EurLiborSwapIfrFixTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_7M, _p_Euribor365_7MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw, _p_BbswTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_NZDLibor, _p_NZDLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Cdor, _p_CdorTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_10M, _p_Euribor365_10MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Zibor, _p_ZiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm5M, _p_Bkbm5MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor11M, _p_Euribor11MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor11M, _p_EURLibor11MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_DailyTenorLibor, _p_DailyTenorLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_TRLibor, _p_TRLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor1Y, _p_EURLibor1YTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor1Y, _p_Bibor1YTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor1Y, _p_Euribor1YTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_GBPLiborON, _p_GBPLiborONTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_CADLiborON, _p_CADLiborONTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_USDLiborON, _p_USDLiborONTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_2W, _p_Euribor365_2WTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor4M, _p_EURLibor4MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor4M, _p_Euribor4MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor9M, _p_EURLibor9MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw3M, _p_Bbsw3MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor9M, _p_Bibor9MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor9M, _p_Euribor9MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_5M, _p_Euribor365_5MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_SEKLibor, _p_SEKLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_DKKLibor, _p_DKKLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm3M, _p_Bkbm3MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Eonia, _p_EoniaTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_THBFIX, _p_THBFIXTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_SwapIndex, _p_SwapIndexTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_OvernightIndexedSwapIndex, _p_OvernightIndexedSwapIndexTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor, _p_BiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_CHFLibor, _p_CHFLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor, _p_EuriborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor2M, _p_EURLibor2MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bibor2M, _p_Bibor2MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor2M, _p_Euribor2MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor7M, _p_EURLibor7MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw1M, _p_Bbsw1MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor7M, _p_Euribor7MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Tibor, _p_TiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw6M, _p_Bbsw6MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_3M, _p_Euribor365_3MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_8M, _p_Euribor365_8MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm1M, _p_Bkbm1MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_11M, _p_Euribor365_11MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm6M, _p_Bkbm6MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Libor, _p_LiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor2W, _p_EURLibor2WTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor2W, _p_Euribor2WTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_SW, _p_Euribor365_SWTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_3W, _p_Euribor365_3WTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixAm, _p_UsdLiborSwapIsdaFixAmTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixAm, _p_JpyLiborSwapIsdaFixAmTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Sofr, _p_SofrTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_OvernightIndex, _p_OvernightIndexTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor5M, _p_EURLibor5MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor5M, _p_Euribor5MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Shibor, _p_ShiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Jibar, _p_JibarTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_SwapSpreadIndex, _p_SwapSpreadIndexTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bbsw4M, _p_Bbsw4MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_1M, _p_Euribor365_1MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_JPYLibor, _p_JPYLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_IborIndex, _p_IborIndexTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor365_6M, _p_Euribor365_6MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixPm, _p_UsdLiborSwapIsdaFixPmTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixPm, _p_JpyLiborSwapIsdaFixPmTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Mosprime, _p_MosprimeTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm4M, _p_Bkbm4MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_EURLibor10M, _p_EURLibor10MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Euribor10M, _p_Euribor10MTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Bkbm, _p_BkbmTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_Nzocr, _p_NzocrTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_CADLibor, _p_CADLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_AUDLibor, _p_AUDLiborTo_p_InterestRateIndex, 0, 0},  {&_swigt__p_USDLibor, _p_USDLiborTo_p_InterestRateIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedDefaultDensityCurveT_Linear_t[] = {  {&_swigt__p_InterpolatedDefaultDensityCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedDiscountCurveT_LogLinear_t[] = {  {&_swigt__p_InterpolatedDiscountCurveT_LogLinear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t[] = {  {&_swigt__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedDiscountCurveT_SplineCubic_t[] = {  {&_swigt__p_InterpolatedDiscountCurveT_SplineCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedForwardCurveT_BackwardFlat_t[] = {  {&_swigt__p_InterpolatedForwardCurveT_BackwardFlat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedHazardRateCurveT_BackwardFlat_t[] = {  {&_swigt__p_InterpolatedHazardRateCurveT_BackwardFlat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t[] = {  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t[] = {  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedSmileSectionT_Cubic_t[] = {  {&_swigt__p_InterpolatedSmileSectionT_Cubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedSmileSectionT_Linear_t[] = {  {&_swigt__p_InterpolatedSmileSectionT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedSmileSectionT_MonotonicCubic_t[] = {  {&_swigt__p_InterpolatedSmileSectionT_MonotonicCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedSmileSectionT_SplineCubic_t[] = {  {&_swigt__p_InterpolatedSmileSectionT_SplineCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedSurvivalProbabilityCurveT_Linear_t[] = {  {&_swigt__p_InterpolatedSurvivalProbabilityCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedYoYInflationCurveT_Linear_t[] = {  {&_swigt__p_InterpolatedYoYInflationCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedYoYOptionletStripperT_Linear_t[] = {  {&_swigt__p_InterpolatedYoYOptionletStripperT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t[] = {  {&_swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroCurveT_Cubic_t[] = {  {&_swigt__p_InterpolatedZeroCurveT_Cubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroCurveT_DefaultLogCubic_t[] = {  {&_swigt__p_InterpolatedZeroCurveT_DefaultLogCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroCurveT_Linear_t[] = {  {&_swigt__p_InterpolatedZeroCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroCurveT_LogLinear_t[] = {  {&_swigt__p_InterpolatedZeroCurveT_LogLinear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroCurveT_MonotonicCubic_t[] = {  {&_swigt__p_InterpolatedZeroCurveT_MonotonicCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroCurveT_SplineCubic_t[] = {  {&_swigt__p_InterpolatedZeroCurveT_SplineCubic_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InterpolatedZeroInflationCurveT_Linear_t[] = {  {&_swigt__p_InterpolatedZeroInflationCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntervalPrice[] = {  {&_swigt__p_IntervalPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeNormal[] = {  {&_swigt__p_InverseCumulativeNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativePoisson[] = {  {&_swigt__p_InverseCumulativePoisson, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t[] = {  {&_swigt__p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseCumulativeStudent[] = {  {&_swigt__p_InverseCumulativeStudent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InverseNonCentralCumulativeChiSquareDistribution[] = {  {&_swigt__p_InverseNonCentralCumulativeChiSquareDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IsdaCdsEngine[] = {  {&_swigt__p_IsdaCdsEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_JPYLibor[] = {  {&_swigt__p_JPYLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_JamshidianSwaptionEngine[] = {  {&_swigt__p_JamshidianSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Jibar[] = {  {&_swigt__p_Jibar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_JpyLiborSwapIsdaFixAm[] = {  {&_swigt__p_JpyLiborSwapIsdaFixAm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_JpyLiborSwapIsdaFixPm[] = {  {&_swigt__p_JpyLiborSwapIsdaFixPm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_JuQuadraticApproximationEngine[] = {  {&_swigt__p_JuQuadraticApproximationEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t[] = {  {&_swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KahaleSmileSection[] = {  {&_swigt__p_KahaleSmileSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KerkhofSeasonality[] = {  {&_swigt__p_KerkhofSeasonality, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KirkEngine[] = {  {&_swigt__p_KirkEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KirkSpreadOptionEngine[] = {  {&_swigt__p_KirkSpreadOptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KlugeExtOUProcess[] = {  {&_swigt__p_KlugeExtOUProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KnuthUniformRng[] = {  {&_swigt__p_KnuthUniformRng, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Kruger[] = {  {&_swigt__p_Kruger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KrugerLog[] = {  {&_swigt__p_KrugerLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LecuyerUniformRng[] = {  {&_swigt__p_LecuyerUniformRng, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LevenbergMarquardt[] = {  {&_swigt__p_LevenbergMarquardt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Libor[] = {  {&_swigt__p_Libor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Linear[] = {  {&_swigt__p_Linear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinearTsrPricer[] = {  {&_swigt__p_LinearTsrPricer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinearTsrPricer__Settings[] = {  {&_swigt__p_LinearTsrPricer__Settings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LocalConstantVol[] = {  {&_swigt__p_LocalConstantVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LocalVolRNDCalculator[] = {  {&_swigt__p_LocalVolRNDCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LocalVolSurface[] = {  {&_swigt__p_LocalVolSurface, 0, 0, 0},  {&_swigt__p_NoExceptLocalVolSurface, _p_NoExceptLocalVolSurfaceTo_p_LocalVolSurface, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LocalVolTermStructure[] = {  {&_swigt__p_LocalVolTermStructure, 0, 0, 0},  {&_swigt__p_LocalConstantVol, _p_LocalConstantVolTo_p_LocalVolTermStructure, 0, 0},  {&_swigt__p_LocalVolSurface, _p_LocalVolSurfaceTo_p_LocalVolTermStructure, 0, 0},  {&_swigt__p_NoExceptLocalVolSurface, _p_NoExceptLocalVolSurfaceTo_p_LocalVolTermStructure, 0, 0},  {&_swigt__p_AndreasenHugeLocalVolAdapter, _p_AndreasenHugeLocalVolAdapterTo_p_LocalVolTermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogLinear[] = {  {&_swigt__p_LogLinear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogNormalSimulatedAnnealing[] = {  {&_swigt__p_LogNormalSimulatedAnnealing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LognormalCmsSpreadPricer[] = {  {&_swigt__p_LognormalCmsSpreadPricer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LsmBasisSystem[] = {  {&_swigt__p_LsmBasisSystem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCAmericanBasketEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCAmericanBasketEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCAmericanBasketEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCAmericanBasketEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCAmericanEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCAmericanEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCAmericanEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCAmericanEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCBarrierEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCBarrierEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCBarrierEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCBarrierEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanBasketEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCEuropeanBasketEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanBasketEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCEuropeanBasketEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCEuropeanEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCEuropeanEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanHestonEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCEuropeanHestonEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEuropeanHestonEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCEuropeanHestonEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEverestEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCEverestEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCEverestEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCEverestEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCHimalayaEngineT_LowDiscrepancy_t[] = {  {&_swigt__p_MCHimalayaEngineT_LowDiscrepancy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MCHimalayaEngineT_PseudoRandom_t[] = {  {&_swigt__p_MCHimalayaEngineT_PseudoRandom_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MTBrownianGeneratorFactory[] = {  {&_swigt__p_MTBrownianGeneratorFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MakeOIS[] = {  {&_swigt__p_MakeOIS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MakeSchedule[] = {  {&_swigt__p_MakeSchedule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MakeVanillaSwap[] = {  {&_swigt__p_MakeVanillaSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MarkovFunctional[] = {  {&_swigt__p_MarkovFunctional, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MarkovFunctional__ModelSettings[] = {  {&_swigt__p_MarkovFunctional__ModelSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Matrix[] = {  {&_swigt__p_Matrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MatrixMultiplicationProxy[] = {  {&_swigt__p_MatrixMultiplicationProxy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MatrixRow[] = {  {&_swigt__p_MatrixRow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MaxBasketPayoff[] = {  {&_swigt__p_MaxBasketPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MersenneTwisterUniformRng[] = {  {&_swigt__p_MersenneTwisterUniformRng, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Merton76Process[] = {  {&_swigt__p_Merton76Process, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MethodOfLinesScheme[] = {  {&_swigt__p_MethodOfLinesScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MidPointCdsEngine[] = {  {&_swigt__p_MidPointCdsEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MinBasketPayoff[] = {  {&_swigt__p_MinBasketPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MirrorGaussianSimulatedAnnealing[] = {  {&_swigt__p_MirrorGaussianSimulatedAnnealing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ModifiedCraigSneydScheme[] = {  {&_swigt__p_ModifiedCraigSneydScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Money[] = {  {&_swigt__p_Money, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MonotonicCubic[] = {  {&_swigt__p_MonotonicCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MonotonicLogCubic[] = {  {&_swigt__p_MonotonicLogCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MoroInverseCumulativeNormal[] = {  {&_swigt__p_MoroInverseCumulativeNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mosprime[] = {  {&_swigt__p_Mosprime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MultiAssetOption[] = {  {&_swigt__p_MultiAssetOption, 0, 0, 0},  {&_swigt__p_SpreadOption, _p_SpreadOptionTo_p_MultiAssetOption, 0, 0},  {&_swigt__p_BasketOption, _p_BasketOptionTo_p_MultiAssetOption, 0, 0},  {&_swigt__p_EverestOption, _p_EverestOptionTo_p_MultiAssetOption, 0, 0},  {&_swigt__p_HimalayaOption, _p_HimalayaOptionTo_p_MultiAssetOption, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MultiPath[] = {  {&_swigt__p_MultiPath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MultiplicativePriceSeasonality[] = {  {&_swigt__p_MultiplicativePriceSeasonality, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NZDLibor[] = {  {&_swigt__p_NZDLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NelsonSiegelFitting[] = {  {&_swigt__p_NelsonSiegelFitting, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NeumannBC[] = {  {&_swigt__p_NeumannBC, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Newton[] = {  {&_swigt__p_Newton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NewtonSafe[] = {  {&_swigt__p_NewtonSafe, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NinePointLinearOp[] = {  {&_swigt__p_NinePointLinearOp, 0, 0, 0},  {&_swigt__p_SecondOrderMixedDerivativeOp, _p_SecondOrderMixedDerivativeOpTo_p_NinePointLinearOp, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NoArbSabrInterpolatedSmileSection[] = {  {&_swigt__p_NoArbSabrInterpolatedSmileSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NoArbSabrSmileSection[] = {  {&_swigt__p_NoArbSabrSmileSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NoConstraint[] = {  {&_swigt__p_NoConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NoExceptLocalVolSurface[] = {  {&_swigt__p_NoExceptLocalVolSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NonCentralCumulativeChiSquareDistribution[] = {  {&_swigt__p_NonCentralCumulativeChiSquareDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NonhomogeneousBoundaryConstraint[] = {  {&_swigt__p_NonhomogeneousBoundaryConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NonstandardSwap[] = {  {&_swigt__p_NonstandardSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NonstandardSwaption[] = {  {&_swigt__p_NonstandardSwaption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NormalDistribution[] = {  {&_swigt__p_NormalDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NthOrderDerivativeOp[] = {  {&_swigt__p_NthOrderDerivativeOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NullParameter[] = {  {&_swigt__p_NullParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NumericHaganPricer[] = {  {&_swigt__p_NumericHaganPricer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Nzocr[] = {  {&_swigt__p_Nzocr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OISRateHelper[] = {  {&_swigt__p_OISRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Observable[] = {  {&_swigt__p_AndreasenHugeVolatilityInterpl, _p_AndreasenHugeVolatilityInterplTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_4M, _p_Euribor365_4MTo_p_Observable, 0, 0},  {&_swigt__p_FlatHazardRate, _p_FlatHazardRateTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseFlatHazardRate, _p_PiecewiseFlatHazardRateTo_p_Observable, 0, 0},  {&_swigt__p_Stock, _p_StockTo_p_Observable, 0, 0},  {&_swigt__p_StochasticProcessArray, _p_StochasticProcessArrayTo_p_Observable, 0, 0},  {&_swigt__p_EuriborSwapIfrFix, _p_EuriborSwapIfrFixTo_p_Observable, 0, 0},  {&_swigt__p_EurLiborSwapIfrFix, _p_EurLiborSwapIfrFixTo_p_Observable, 0, 0},  {&_swigt__p_CHFLibor, _p_CHFLiborTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_SW, _p_Euribor365_SWTo_p_Observable, 0, 0},  {&_swigt__p_Euribor1Y, _p_Euribor1YTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor1Y, _p_EURLibor1YTo_p_Observable, 0, 0},  {&_swigt__p_Bibor1Y, _p_Bibor1YTo_p_Observable, 0, 0},  {&_swigt__p_BlackConstantVol, _p_BlackConstantVolTo_p_Observable, 0, 0},  {&_swigt__p_LocalConstantVol, _p_LocalConstantVolTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_Cubic_t, _p_InterpolatedSmileSectionT_Cubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_MonotonicCubic_t, _p_InterpolatedSmileSectionT_MonotonicCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_SplineCubic_t, _p_InterpolatedSmileSectionT_SplineCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t, _p_InterpolatedDiscountCurveT_MonotonicLogCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_SplineCubic_t, _p_InterpolatedDiscountCurveT_SplineCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_Cubic_t, _p_InterpolatedZeroCurveT_Cubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_SplineCubic_t, _p_InterpolatedZeroCurveT_SplineCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_DefaultLogCubic_t, _p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_MonotonicCubic_t, _p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_Observable, 0, 0},  {&_swigt__p_CoxIngersollRoss, _p_CoxIngersollRossTo_p_Observable, 0, 0},  {&_swigt__p_ExtendedCoxIngersollRoss, _p_ExtendedCoxIngersollRossTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseKrugerZero, _p_PiecewiseKrugerZeroTo_p_Observable, 0, 0},  {&_swigt__p_CPISwap, _p_CPISwapTo_p_Observable, 0, 0},  {&_swigt__p_ConstantYoYOptionletVolatility, _p_ConstantYoYOptionletVolatilityTo_p_Observable, 0, 0},  {&_swigt__p_ConstantOptionletVolatility, _p_ConstantOptionletVolatilityTo_p_Observable, 0, 0},  {&_swigt__p_ConstantSwaptionVolatility, _p_ConstantSwaptionVolatilityTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationFloor, _p_YoYInflationFloorTo_p_Observable, 0, 0},  {&_swigt__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t, _p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_tTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_11M, _p_Euribor365_11MTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationCap, _p_YoYInflationCapTo_p_Observable, 0, 0},  {&_swigt__p_Robor, _p_RoborTo_p_Observable, 0, 0},  {&_swigt__p_GBPLibor, _p_GBPLiborTo_p_Observable, 0, 0},  {&_swigt__p_BlackVarianceCurve, _p_BlackVarianceCurveTo_p_Observable, 0, 0},  {&_swigt__p_Euribor2M, _p_Euribor2MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor2M, _p_EURLibor2MTo_p_Observable, 0, 0},  {&_swigt__p_Bibor2M, _p_Bibor2MTo_p_Observable, 0, 0},  {&_swigt__p_Gsr, _p_GsrTo_p_Observable, 0, 0},  {&_swigt__p_ZeroCouponBond, _p_ZeroCouponBondTo_p_Observable, 0, 0},  {&_swigt__p_CallableZeroCouponBond, _p_CallableZeroCouponBondTo_p_Observable, 0, 0},  {&_swigt__p_ConvertibleZeroCouponBond, _p_ConvertibleZeroCouponBondTo_p_Observable, 0, 0},  {&_swigt__p_ConvertibleFixedCouponBond, _p_ConvertibleFixedCouponBondTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_5M, _p_Euribor365_5MTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedForwardCurveT_BackwardFlat_t, _p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedHazardRateCurveT_BackwardFlat_t, _p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_Observable, 0, 0},  {&_swigt__p_Shibor, _p_ShiborTo_p_Observable, 0, 0},  {&_swigt__p_Bbsw1M, _p_Bbsw1MTo_p_Observable, 0, 0},  {&_swigt__p_VanillaSwap, _p_VanillaSwapTo_p_Observable, 0, 0},  {&_swigt__p_Instrument, _p_InstrumentTo_p_Observable, 0, 0},  {&_swigt__p_CompositeInstrument, _p_CompositeInstrumentTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor2W, _p_EURLibor2WTo_p_Observable, 0, 0},  {&_swigt__p_Euribor2W, _p_Euribor2WTo_p_Observable, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t, _p_ZabrInterpolatedSmileSectionT_ZabrFullFd_tTo_p_Observable, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrFullFd_t, _p_ZabrSmileSectionT_ZabrFullFd_tTo_p_Observable, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixPm, _p_UsdLiborSwapIsdaFixPmTo_p_Observable, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixPm, _p_JpyLiborSwapIsdaFixPmTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseCubicZero, _p_PiecewiseCubicZeroTo_p_Observable, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t, _p_ZabrSmileSectionT_ZabrShortMaturityNormal_tTo_p_Observable, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t, _p_ZabrSmileSectionT_ZabrShortMaturityLognormal_tTo_p_Observable, 0, 0},  {&_swigt__p_SwaptionVolCube1, _p_SwaptionVolCube1To_p_Observable, 0, 0},  {&_swigt__p_SwaptionVolCube2, _p_SwaptionVolCube2To_p_Observable, 0, 0},  {&_swigt__p_GlobalLinearSimpleZeroCurve, _p_GlobalLinearSimpleZeroCurveTo_p_Observable, 0, 0},  {&_swigt__p_IndexedCashFlow, _p_IndexedCashFlowTo_p_Observable, 0, 0},  {&_swigt__p_SimpleCashFlow, _p_SimpleCashFlowTo_p_Observable, 0, 0},  {&_swigt__p_CashFlow, _p_CashFlowTo_p_Observable, 0, 0},  {&_swigt__p_BlackKarasinski, _p_BlackKarasinskiTo_p_Observable, 0, 0},  {&_swigt__p_OvernightIndexedCoupon, _p_OvernightIndexedCouponTo_p_Observable, 0, 0},  {&_swigt__p_CappedFlooredCoupon, _p_CappedFlooredCouponTo_p_Observable, 0, 0},  {&_swigt__p_CappedFlooredIborCoupon, _p_CappedFlooredIborCouponTo_p_Observable, 0, 0},  {&_swigt__p_CappedFlooredCmsSpreadCoupon, _p_CappedFlooredCmsSpreadCouponTo_p_Observable, 0, 0},  {&_swigt__p_IborCoupon, _p_IborCouponTo_p_Observable, 0, 0},  {&_swigt__p_CmsSpreadCoupon, _p_CmsSpreadCouponTo_p_Observable, 0, 0},  {&_swigt__p_InflationCoupon, _p_InflationCouponTo_p_Observable, 0, 0},  {&_swigt__p_Euribor3M, _p_Euribor3MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor3M, _p_EURLibor3MTo_p_Observable, 0, 0},  {&_swigt__p_Bibor3M, _p_Bibor3MTo_p_Observable, 0, 0},  {&_swigt__p_CPICoupon, _p_CPICouponTo_p_Observable, 0, 0},  {&_swigt__p_FixedRateCoupon, _p_FixedRateCouponTo_p_Observable, 0, 0},  {&_swigt__p_FloatingRateCoupon, _p_FloatingRateCouponTo_p_Observable, 0, 0},  {&_swigt__p_CappedFlooredCmsCoupon, _p_CappedFlooredCmsCouponTo_p_Observable, 0, 0},  {&_swigt__p_CmsCoupon, _p_CmsCouponTo_p_Observable, 0, 0},  {&_swigt__p_Coupon, _p_CouponTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_6M, _p_Euribor365_6MTo_p_Observable, 0, 0},  {&_swigt__p_Index, _p_IndexTo_p_Observable, 0, 0},  {&_swigt__p_Euribor10M, _p_Euribor10MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor10M, _p_EURLibor10MTo_p_Observable, 0, 0},  {&_swigt__p_Bbsw2M, _p_Bbsw2MTo_p_Observable, 0, 0},  {&_swigt__p_YYEUHICPr, _p_YYEUHICPrTo_p_Observable, 0, 0},  {&_swigt__p_OneFactorAffineModel, _p_OneFactorAffineModelTo_p_Observable, 0, 0},  {&_swigt__p_ShortRateModel, _p_ShortRateModelTo_p_Observable, 0, 0},  {&_swigt__p_HestonSLVProcess, _p_HestonSLVProcessTo_p_Observable, 0, 0},  {&_swigt__p_StochasticProcess, _p_StochasticProcessTo_p_Observable, 0, 0},  {&_swigt__p_GeneralizedBlackScholesProcess, _p_GeneralizedBlackScholesProcessTo_p_Observable, 0, 0},  {&_swigt__p_BlackScholesProcess, _p_BlackScholesProcessTo_p_Observable, 0, 0},  {&_swigt__p_BlackScholesMertonProcess, _p_BlackScholesMertonProcessTo_p_Observable, 0, 0},  {&_swigt__p_BlackProcess, _p_BlackProcessTo_p_Observable, 0, 0},  {&_swigt__p_GarmanKohlagenProcess, _p_GarmanKohlagenProcessTo_p_Observable, 0, 0},  {&_swigt__p_Merton76Process, _p_Merton76ProcessTo_p_Observable, 0, 0},  {&_swigt__p_GeometricBrownianMotionProcess, _p_GeometricBrownianMotionProcessTo_p_Observable, 0, 0},  {&_swigt__p_VarianceGammaProcess, _p_VarianceGammaProcessTo_p_Observable, 0, 0},  {&_swigt__p_HestonProcess, _p_HestonProcessTo_p_Observable, 0, 0},  {&_swigt__p_BatesProcess, _p_BatesProcessTo_p_Observable, 0, 0},  {&_swigt__p_HullWhiteProcess, _p_HullWhiteProcessTo_p_Observable, 0, 0},  {&_swigt__p_HullWhiteForwardProcess, _p_HullWhiteForwardProcessTo_p_Observable, 0, 0},  {&_swigt__p_G2Process, _p_G2ProcessTo_p_Observable, 0, 0},  {&_swigt__p_G2ForwardProcess, _p_G2ForwardProcessTo_p_Observable, 0, 0},  {&_swigt__p_GsrProcess, _p_GsrProcessTo_p_Observable, 0, 0},  {&_swigt__p_OrnsteinUhlenbeckProcess, _p_OrnsteinUhlenbeckProcessTo_p_Observable, 0, 0},  {&_swigt__p_ExtendedOrnsteinUhlenbeckProcess, _p_ExtendedOrnsteinUhlenbeckProcessTo_p_Observable, 0, 0},  {&_swigt__p_ExtOUWithJumpsProcess, _p_ExtOUWithJumpsProcessTo_p_Observable, 0, 0},  {&_swigt__p_KlugeExtOUProcess, _p_KlugeExtOUProcessTo_p_Observable, 0, 0},  {&_swigt__p_GJRGARCHProcess, _p_GJRGARCHProcessTo_p_Observable, 0, 0},  {&_swigt__p_NZDLibor, _p_NZDLiborTo_p_Observable, 0, 0},  {&_swigt__p_USDLibor, _p_USDLiborTo_p_Observable, 0, 0},  {&_swigt__p_AUDLibor, _p_AUDLiborTo_p_Observable, 0, 0},  {&_swigt__p_CADLibor, _p_CADLiborTo_p_Observable, 0, 0},  {&_swigt__p_Euribor3W, _p_Euribor3WTo_p_Observable, 0, 0},  {&_swigt__p_Aonia, _p_AoniaTo_p_Observable, 0, 0},  {&_swigt__p_OvernightIndex, _p_OvernightIndexTo_p_Observable, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrLocalVolatility_t, _p_ZabrSmileSectionT_ZabrLocalVolatility_tTo_p_Observable, 0, 0},  {&_swigt__p_SwaptionVolatilityMatrix, _p_SwaptionVolatilityMatrixTo_p_Observable, 0, 0},  {&_swigt__p_CallableBond, _p_CallableBondTo_p_Observable, 0, 0},  {&_swigt__p_EUHICPXT, _p_EUHICPXTTo_p_Observable, 0, 0},  {&_swigt__p_YYEUHICPXT, _p_YYEUHICPXTTo_p_Observable, 0, 0},  {&_swigt__p_JPYLibor, _p_JPYLiborTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_Joshi4_t, _p_BinomialConvertibleEngineT_Joshi4_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_Joshi4_t, _p_BinomialVanillaEngineT_Joshi4_tTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseKrugerLogDiscount, _p_PiecewiseKrugerLogDiscountTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseSplineCubicDiscount, _p_PiecewiseSplineCubicDiscountTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseLogCubicDiscount, _p_PiecewiseLogCubicDiscountTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseLogLinearDiscount, _p_PiecewiseLogLinearDiscountTo_p_Observable, 0, 0},  {&_swigt__p_NonstandardSwap, _p_NonstandardSwapTo_p_Observable, 0, 0},  {&_swigt__p_FDBermudanEngineT_CrankNicolson_t, _p_FDBermudanEngineT_CrankNicolson_tTo_p_Observable, 0, 0},  {&_swigt__p_FDEuropeanEngineT_CrankNicolson_t, _p_FDEuropeanEngineT_CrankNicolson_tTo_p_Observable, 0, 0},  {&_swigt__p_FDAmericanEngineT_CrankNicolson_t, _p_FDAmericanEngineT_CrankNicolson_tTo_p_Observable, 0, 0},  {&_swigt__p_FDShoutEngineT_CrankNicolson_t, _p_FDShoutEngineT_CrankNicolson_tTo_p_Observable, 0, 0},  {&_swigt__p_FDDividendEuropeanEngineT_CrankNicolson_t, _p_FDDividendEuropeanEngineT_CrankNicolson_tTo_p_Observable, 0, 0},  {&_swigt__p_FDDividendAmericanEngineT_CrankNicolson_t, _p_FDDividendAmericanEngineT_CrankNicolson_tTo_p_Observable, 0, 0},  {&_swigt__p_SimpleQuote, _p_SimpleQuoteTo_p_Observable, 0, 0},  {&_swigt__p_CreditDefaultSwap, _p_CreditDefaultSwapTo_p_Observable, 0, 0},  {&_swigt__p_SwaptionVolatilityDiscrete, _p_SwaptionVolatilityDiscreteTo_p_Observable, 0, 0},  {&_swigt__p_UKRPI, _p_UKRPITo_p_Observable, 0, 0},  {&_swigt__p_Euribor4M, _p_Euribor4MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor4M, _p_EURLibor4MTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_7M, _p_Euribor365_7MTo_p_Observable, 0, 0},  {&_swigt__p_Euribor11M, _p_Euribor11MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor11M, _p_EURLibor11MTo_p_Observable, 0, 0},  {&_swigt__p_Bbsw3M, _p_Bbsw3MTo_p_Observable, 0, 0},  {&_swigt__p_CalibratedModel, _p_CalibratedModelTo_p_Observable, 0, 0},  {&_swigt__p_Gaussian1dModel, _p_Gaussian1dModelTo_p_Observable, 0, 0},  {&_swigt__p_FloatFloatSwap, _p_FloatFloatSwapTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_MultiAssetOption, _p_MultiAssetOptionTo_p_Observable, 0, 0},  {&_swigt__p_BarrierOption, _p_BarrierOptionTo_p_Observable, 0, 0},  {&_swigt__p_DividendBarrierOption, _p_DividendBarrierOptionTo_p_Observable, 0, 0},  {&_swigt__p_ContinuousAveragingAsianOption, _p_ContinuousAveragingAsianOptionTo_p_Observable, 0, 0},  {&_swigt__p_EuropeanOption, _p_EuropeanOptionTo_p_Observable, 0, 0},  {&_swigt__p_OneAssetOption, _p_OneAssetOptionTo_p_Observable, 0, 0},  {&_swigt__p_DiscreteAveragingAsianOption, _p_DiscreteAveragingAsianOptionTo_p_Observable, 0, 0},  {&_swigt__p_DoubleBarrierOption, _p_DoubleBarrierOptionTo_p_Observable, 0, 0},  {&_swigt__p_QuantoDoubleBarrierOption, _p_QuantoDoubleBarrierOptionTo_p_Observable, 0, 0},  {&_swigt__p_SpreadOption, _p_SpreadOptionTo_p_Observable, 0, 0},  {&_swigt__p_BasketOption, _p_BasketOptionTo_p_Observable, 0, 0},  {&_swigt__p_EverestOption, _p_EverestOptionTo_p_Observable, 0, 0},  {&_swigt__p_BiborSW, _p_BiborSWTo_p_Observable, 0, 0},  {&_swigt__p_EuriborSW, _p_EuriborSWTo_p_Observable, 0, 0},  {&_swigt__p_EURLiborSW, _p_EURLiborSWTo_p_Observable, 0, 0},  {&_swigt__p_HimalayaOption, _p_HimalayaOptionTo_p_Observable, 0, 0},  {&_swigt__p_VanillaOption, _p_VanillaOptionTo_p_Observable, 0, 0},  {&_swigt__p_ForwardVanillaOption, _p_ForwardVanillaOptionTo_p_Observable, 0, 0},  {&_swigt__p_QuantoVanillaOption, _p_QuantoVanillaOptionTo_p_Observable, 0, 0},  {&_swigt__p_QuantoForwardVanillaOption, _p_QuantoForwardVanillaOptionTo_p_Observable, 0, 0},  {&_swigt__p_DividendVanillaOption, _p_DividendVanillaOptionTo_p_Observable, 0, 0},  {&_swigt__p_VanillaSwingOption, _p_VanillaSwingOptionTo_p_Observable, 0, 0},  {&_swigt__p_CdsOption, _p_CdsOptionTo_p_Observable, 0, 0},  {&_swigt__p_Option, _p_OptionTo_p_Observable, 0, 0},  {&_swigt__p_StochasticProcess1D, _p_StochasticProcess1DTo_p_Observable, 0, 0},  {&_swigt__p_AmortizingPayment, _p_AmortizingPaymentTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_GbpLiborSwapIsdaFix, _p_GbpLiborSwapIsdaFixTo_p_Observable, 0, 0},  {&_swigt__p_ChfLiborSwapIsdaFix, _p_ChfLiborSwapIsdaFixTo_p_Observable, 0, 0},  {&_swigt__p_Zibor, _p_ZiborTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_Trigeorgis_t, _p_BinomialConvertibleEngineT_Trigeorgis_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_Trigeorgis_t, _p_BinomialVanillaEngineT_Trigeorgis_tTo_p_Observable, 0, 0},  {&_swigt__p_Bkbm1M, _p_Bkbm1MTo_p_Observable, 0, 0},  {&_swigt__p_BlackCapFloorEngine, _p_BlackCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_BachelierCapFloorEngine, _p_BachelierCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_BlackCdsOptionEngine, _p_BlackCdsOptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_Gaussian1dSwaptionEngine, _p_Gaussian1dSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_Gaussian1dJamshidianSwaptionEngine, _p_Gaussian1dJamshidianSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_Gaussian1dNonstandardSwaptionEngine, _p_Gaussian1dNonstandardSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_Gaussian1dFloatFloatSwaptionEngine, _p_Gaussian1dFloatFloatSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_BlackSwaptionEngine, _p_BlackSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_BachelierSwaptionEngine, _p_BachelierSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_BlackCallableFixedRateBondEngine, _p_BlackCallableFixedRateBondEngineTo_p_Observable, 0, 0},  {&_swigt__p_TreeCallableFixedRateBondEngine, _p_TreeCallableFixedRateBondEngineTo_p_Observable, 0, 0},  {&_swigt__p_DiscountingBondEngine, _p_DiscountingBondEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdHullWhiteSwaptionEngine, _p_FdHullWhiteSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdG2SwaptionEngine, _p_FdG2SwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_G2SwaptionEngine, _p_G2SwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_TreeCapFloorEngine, _p_TreeCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticCapFloorEngine, _p_AnalyticCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_TreeSwaptionEngine, _p_TreeSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_JamshidianSwaptionEngine, _p_JamshidianSwaptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationBachelierCapFloorEngine, _p_YoYInflationBachelierCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationUnitDisplacedBlackCapFloorEngine, _p_YoYInflationUnitDisplacedBlackCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationBlackCapFloorEngine, _p_YoYInflationBlackCapFloorEngineTo_p_Observable, 0, 0},  {&_swigt__p_DiscountingSwapEngine, _p_DiscountingSwapEngineTo_p_Observable, 0, 0},  {&_swigt__p_StulzEngine, _p_StulzEngineTo_p_Observable, 0, 0},  {&_swigt__p_KirkSpreadOptionEngine, _p_KirkSpreadOptionEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticEuropeanEngine, _p_AnalyticEuropeanEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticHestonEngine, _p_AnalyticHestonEngineTo_p_Observable, 0, 0},  {&_swigt__p_COSHestonEngine, _p_COSHestonEngineTo_p_Observable, 0, 0},  {&_swigt__p_ExponentialFittingHestonEngine, _p_ExponentialFittingHestonEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticPTDHestonEngine, _p_AnalyticPTDHestonEngineTo_p_Observable, 0, 0},  {&_swigt__p_IntegralEngine, _p_IntegralEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdBlackScholesAsianEngine, _p_FdBlackScholesAsianEngineTo_p_Observable, 0, 0},  {&_swigt__p_BaroneAdesiWhaleyApproximationEngine, _p_BaroneAdesiWhaleyApproximationEngineTo_p_Observable, 0, 0},  {&_swigt__p_BjerksundStenslandApproximationEngine, _p_BjerksundStenslandApproximationEngineTo_p_Observable, 0, 0},  {&_swigt__p_JuQuadraticApproximationEngine, _p_JuQuadraticApproximationEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDigitalAmericanEngine, _p_AnalyticDigitalAmericanEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDividendEuropeanEngine, _p_AnalyticDividendEuropeanEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticBarrierEngine, _p_AnalyticBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticCEVEngine, _p_AnalyticCEVEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdBlackScholesBarrierEngine, _p_FdBlackScholesBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdHestonBarrierEngine, _p_FdHestonBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticBinaryBarrierEngine, _p_AnalyticBinaryBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_ForwardEuropeanEngine, _p_ForwardEuropeanEngineTo_p_Observable, 0, 0},  {&_swigt__p_QuantoEuropeanEngine, _p_QuantoEuropeanEngineTo_p_Observable, 0, 0},  {&_swigt__p_QuantoForwardEuropeanEngine, _p_QuantoForwardEuropeanEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDoubleBarrierEngine, _p_AnalyticDoubleBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdHestonDoubleBarrierEngine, _p_FdHestonDoubleBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_WulinYongDoubleBarrierEngine, _p_WulinYongDoubleBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_VannaVolgaBarrierEngine, _p_VannaVolgaBarrierEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticGJRGARCHEngine, _p_AnalyticGJRGARCHEngineTo_p_Observable, 0, 0},  {&_swigt__p_IsdaCdsEngine, _p_IsdaCdsEngineTo_p_Observable, 0, 0},  {&_swigt__p_IntegralCdsEngine, _p_IntegralCdsEngineTo_p_Observable, 0, 0},  {&_swigt__p_MidPointCdsEngine, _p_MidPointCdsEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticBSMHullWhiteEngine, _p_AnalyticBSMHullWhiteEngineTo_p_Observable, 0, 0},  {&_swigt__p_Fd2dBlackScholesVanillaEngine, _p_Fd2dBlackScholesVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_KirkEngine, _p_KirkEngineTo_p_Observable, 0, 0},  {&_swigt__p_PricingEngine, _p_PricingEngineTo_p_Observable, 0, 0},  {&_swigt__p_BatesEngine, _p_BatesEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdBlackScholesVanillaEngine, _p_FdBlackScholesVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdOrnsteinUhlenbeckVanillaEngine, _p_FdOrnsteinUhlenbeckVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdBatesVanillaEngine, _p_FdBatesVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdHestonVanillaEngine, _p_FdHestonVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdCEVVanillaEngine, _p_FdCEVVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdSabrVanillaEngine, _p_FdSabrVanillaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdBlackScholesRebateEngine, _p_FdBlackScholesRebateEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdHestonRebateEngine, _p_FdHestonRebateEngineTo_p_Observable, 0, 0},  {&_swigt__p_VarianceGammaEngine, _p_VarianceGammaEngineTo_p_Observable, 0, 0},  {&_swigt__p_FFTVarianceGammaEngine, _p_FFTVarianceGammaEngineTo_p_Observable, 0, 0},  {&_swigt__p_ContinuousArithmeticAsianLevyEngine, _p_ContinuousArithmeticAsianLevyEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDigitalAmericanKOEngine, _p_AnalyticDigitalAmericanKOEngineTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDoubleBarrierBinaryEngine, _p_AnalyticDoubleBarrierBinaryEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdSimpleBSSwingEngine, _p_FdSimpleBSSwingEngineTo_p_Observable, 0, 0},  {&_swigt__p_FdSimpleExtOUJumpSwingEngine, _p_FdSimpleExtOUJumpSwingEngineTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseTimeDependentHestonModel, _p_PiecewiseTimeDependentHestonModelTo_p_Observable, 0, 0},  {&_swigt__p_HestonModel, _p_HestonModelTo_p_Observable, 0, 0},  {&_swigt__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t, _p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_tTo_p_Observable, 0, 0},  {&_swigt__p_Euribor5M, _p_Euribor5MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor5M, _p_EURLibor5MTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_8M, _p_Euribor365_8MTo_p_Observable, 0, 0},  {&_swigt__p_G2, _p_G2To_p_Observable, 0, 0},  {&_swigt__p_Bbsw4M, _p_Bbsw4MTo_p_Observable, 0, 0},  {&_swigt__p_CapFloorTermVolatilityStructure, _p_CapFloorTermVolatilityStructureTo_p_Observable, 0, 0},  {&_swigt__p_DefaultProbabilityTermStructure, _p_DefaultProbabilityTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_ZeroInflationTermStructure, _p_ZeroInflationTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationTermStructure, _p_YoYInflationTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_InflationTermStructure, _p_InflationTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_SwaptionVolatilityStructure, _p_SwaptionVolatilityStructureTo_p_Observable, 0, 0},  {&_swigt__p_OptionletVolatilityStructure, _p_OptionletVolatilityStructureTo_p_Observable, 0, 0},  {&_swigt__p_LocalVolTermStructure, _p_LocalVolTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_BlackVolTermStructure, _p_BlackVolTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_VolatilityTermStructure, _p_VolatilityTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_TermStructure, _p_TermStructureTo_p_Observable, 0, 0},  {&_swigt__p_ForwardSpreadedTermStructure, _p_ForwardSpreadedTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_ZeroSpreadedTermStructure, _p_ZeroSpreadedTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_ImpliedTermStructure, _p_ImpliedTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_YieldTermStructure, _p_YieldTermStructureTo_p_Observable, 0, 0},  {&_swigt__p_IborIndex, _p_IborIndexTo_p_Observable, 0, 0},  {&_swigt__p_Pribor, _p_PriborTo_p_Observable, 0, 0},  {&_swigt__p_YYUSCPI, _p_YYUSCPITo_p_Observable, 0, 0},  {&_swigt__p_ZACPI, _p_ZACPITo_p_Observable, 0, 0},  {&_swigt__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t, _p_MCDiscreteGeometricAPEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t, _p_MCDiscreteArithmeticASEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t, _p_MCDiscreteArithmeticAPEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCBarrierEngineT_PseudoRandom_t, _p_MCBarrierEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanEngineT_PseudoRandom_t, _p_MCEuropeanEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCAmericanEngineT_PseudoRandom_t, _p_MCAmericanEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanHestonEngineT_PseudoRandom_t, _p_MCEuropeanHestonEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t, _p_MCEuropeanGJRGARCHEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanBasketEngineT_PseudoRandom_t, _p_MCEuropeanBasketEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCAmericanBasketEngineT_PseudoRandom_t, _p_MCAmericanBasketEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEverestEngineT_PseudoRandom_t, _p_MCEverestEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_MCHimalayaEngineT_PseudoRandom_t, _p_MCHimalayaEngineT_PseudoRandom_tTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseLinearZero, _p_PiecewiseLinearZeroTo_p_Observable, 0, 0},  {&_swigt__p_YYUKRPIr, _p_YYUKRPIrTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_CapFloorTermVolCurve, _p_CapFloorTermVolCurveTo_p_Observable, 0, 0},  {&_swigt__p_Bond, _p_BondTo_p_Observable, 0, 0},  {&_swigt__p_Bkbm2M, _p_Bkbm2MTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_BootstrapHelperT_YoYInflationTermStructure_t, _p_BootstrapHelperT_YoYInflationTermStructure_tTo_p_Observable, 0, 0},  {&_swigt__p_BootstrapHelperT_ZeroInflationTermStructure_t, _p_BootstrapHelperT_ZeroInflationTermStructure_tTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseConvexMonotoneZero, _p_PiecewiseConvexMonotoneZeroTo_p_Observable, 0, 0},  {&_swigt__p_Floor, _p_FloorTo_p_Observable, 0, 0},  {&_swigt__p_OvernightIndexedSwap, _p_OvernightIndexedSwapTo_p_Observable, 0, 0},  {&_swigt__p_DerivedQuoteT_UnaryFunction_t, _p_DerivedQuoteT_UnaryFunction_tTo_p_Observable, 0, 0},  {&_swigt__p_CompositeQuoteT_BinaryFunction_t, _p_CompositeQuoteT_BinaryFunction_tTo_p_Observable, 0, 0},  {&_swigt__p_Euribor6M, _p_Euribor6MTo_p_Observable, 0, 0},  {&_swigt__p_Bibor6M, _p_Bibor6MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor6M, _p_EURLibor6MTo_p_Observable, 0, 0},  {&_swigt__p_Sonia, _p_SoniaTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_9M, _p_Euribor365_9MTo_p_Observable, 0, 0},  {&_swigt__p_BootstrapHelperT_YoYOptionletVolatilitySurface_t, _p_BootstrapHelperT_YoYOptionletVolatilitySurface_tTo_p_Observable, 0, 0},  {&_swigt__p_YYFRHICPr, _p_YYFRHICPrTo_p_Observable, 0, 0},  {&_swigt__p_CallableFixedRateBond, _p_CallableFixedRateBondTo_p_Observable, 0, 0},  {&_swigt__p_ConvertibleFloatingRateBond, _p_ConvertibleFloatingRateBondTo_p_Observable, 0, 0},  {&_swigt__p_CmsRateBond, _p_CmsRateBondTo_p_Observable, 0, 0},  {&_swigt__p_FloatingRateBond, _p_FloatingRateBondTo_p_Observable, 0, 0},  {&_swigt__p_AmortizingFloatingRateBond, _p_AmortizingFloatingRateBondTo_p_Observable, 0, 0},  {&_swigt__p_AmortizingFixedRateBond, _p_AmortizingFixedRateBondTo_p_Observable, 0, 0},  {&_swigt__p_FixedRateBond, _p_FixedRateBondTo_p_Observable, 0, 0},  {&_swigt__p_Bbsw5M, _p_Bbsw5MTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationCollar, _p_YoYInflationCollarTo_p_Observable, 0, 0},  {&_swigt__p_Nzocr, _p_NzocrTo_p_Observable, 0, 0},  {&_swigt__p_Redemption, _p_RedemptionTo_p_Observable, 0, 0},  {&_swigt__p_Collar, _p_CollarTo_p_Observable, 0, 0},  {&_swigt__p_HullWhite, _p_HullWhiteTo_p_Observable, 0, 0},  {&_swigt__p_NoArbSabrInterpolatedSmileSection, _p_NoArbSabrInterpolatedSmileSectionTo_p_Observable, 0, 0},  {&_swigt__p_NoArbSabrSmileSection, _p_NoArbSabrSmileSectionTo_p_Observable, 0, 0},  {&_swigt__p_SmileSection, _p_SmileSectionTo_p_Observable, 0, 0},  {&_swigt__p_SabrSmileSection, _p_SabrSmileSectionTo_p_Observable, 0, 0},  {&_swigt__p_FlatSmileSection, _p_FlatSmileSectionTo_p_Observable, 0, 0},  {&_swigt__p_KahaleSmileSection, _p_KahaleSmileSectionTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t, _p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_Tian_t, _p_BinomialVanillaEngineT_Tian_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_Tian_t, _p_BinomialConvertibleEngineT_Tian_tTo_p_Observable, 0, 0},  {&_swigt__p_Jibar, _p_JibarTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_LeisenReimer_t, _p_BinomialVanillaEngineT_LeisenReimer_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_LeisenReimer_t, _p_BinomialConvertibleEngineT_LeisenReimer_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_Observable, 0, 0, 0},  {&_swigt__p_Bkbm3M, _p_Bkbm3MTo_p_Observable, 0, 0},  {&_swigt__p_Cdor, _p_CdorTo_p_Observable, 0, 0},  {&_swigt__p_DKKLibor, _p_DKKLiborTo_p_Observable, 0, 0},  {&_swigt__p_SEKLibor, _p_SEKLiborTo_p_Observable, 0, 0},  {&_swigt__p_ZeroCouponInflationSwap, _p_ZeroCouponInflationSwapTo_p_Observable, 0, 0},  {&_swigt__p_YearOnYearInflationSwap, _p_YearOnYearInflationSwapTo_p_Observable, 0, 0},  {&_swigt__p_Euribor7M, _p_Euribor7MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor7M, _p_EURLibor7MTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t, _p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_CPIBond, _p_CPIBondTo_p_Observable, 0, 0},  {&_swigt__p_Bbsw6M, _p_Bbsw6MTo_p_Observable, 0, 0},  {&_swigt__p_OvernightIndexedSwapIndex, _p_OvernightIndexedSwapIndexTo_p_Observable, 0, 0},  {&_swigt__p_SwapIndex, _p_SwapIndexTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_JarrowRudd_t, _p_BinomialVanillaEngineT_JarrowRudd_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_JarrowRudd_t, _p_BinomialConvertibleEngineT_JarrowRudd_tTo_p_Observable, 0, 0},  {&_swigt__p_DeltaVolQuote, _p_DeltaVolQuoteTo_p_Observable, 0, 0},  {&_swigt__p_Wibor, _p_WiborTo_p_Observable, 0, 0},  {&_swigt__p_Forward, _p_ForwardTo_p_Observable, 0, 0},  {&_swigt__p_FixedRateBondForward, _p_FixedRateBondForwardTo_p_Observable, 0, 0},  {&_swigt__p_Swaption, _p_SwaptionTo_p_Observable, 0, 0},  {&_swigt__p_NonstandardSwaption, _p_NonstandardSwaptionTo_p_Observable, 0, 0},  {&_swigt__p_FloatFloatSwaption, _p_FloatFloatSwaptionTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseLinearForward, _p_PiecewiseLinearForwardTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseFlatForward, _p_PiecewiseFlatForwardTo_p_Observable, 0, 0},  {&_swigt__p_FlatForward, _p_FlatForwardTo_p_Observable, 0, 0},  {&_swigt__p_InterestRateIndex, _p_InterestRateIndexTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine, _p_AnalyticDiscreteGeometricAverageStrikeAsianEngineTo_p_Observable, 0, 0},  {&_swigt__p_Bkbm4M, _p_Bkbm4MTo_p_Observable, 0, 0},  {&_swigt__p_MarkovFunctional, _p_MarkovFunctionalTo_p_Observable, 0, 0},  {&_swigt__p_Bibor, _p_BiborTo_p_Observable, 0, 0},  {&_swigt__p_EUHICP, _p_EUHICPTo_p_Observable, 0, 0},  {&_swigt__p_YYEUHICP, _p_YYEUHICPTo_p_Observable, 0, 0},  {&_swigt__p_CapFloorTermVolSurface, _p_CapFloorTermVolSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_YoYCapFloorTermPriceSurface, _p_YoYCapFloorTermPriceSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationCapFloorTermPriceSurface, _p_YoYInflationCapFloorTermPriceSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_LocalVolSurface, _p_LocalVolSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_NoExceptLocalVolSurface, _p_NoExceptLocalVolSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_BlackVarianceSurface, _p_BlackVarianceSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_HestonBlackVolSurface, _p_HestonBlackVolSurfaceTo_p_Observable, 0, 0},  {&_swigt__p_YoYOptionletVolatilitySurface, _p_YoYOptionletVolatilitySurfaceTo_p_Observable, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixA, _p_EurLiborSwapIsdaFixATo_p_Observable, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixA, _p_EuriborSwapIsdaFixATo_p_Observable, 0, 0},  {&_swigt__p_Sofr, _p_SofrTo_p_Observable, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixB, _p_EuriborSwapIsdaFixBTo_p_Observable, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixB, _p_EurLiborSwapIsdaFixBTo_p_Observable, 0, 0},  {&_swigt__p_Euribor8M, _p_Euribor8MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor8M, _p_EURLibor8MTo_p_Observable, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixAm, _p_JpyLiborSwapIsdaFixAmTo_p_Observable, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixAm, _p_UsdLiborSwapIsdaFixAmTo_p_Observable, 0, 0},  {&_swigt__p_Libor, _p_LiborTo_p_Observable, 0, 0},  {&_swigt__p_FittedBondDiscountCurve, _p_FittedBondDiscountCurveTo_p_Observable, 0, 0},  {&_swigt__p_YYUSCPIr, _p_YYUSCPIrTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_1M, _p_Euribor365_1MTo_p_Observable, 0, 0},  {&_swigt__p_Mosprime, _p_MosprimeTo_p_Observable, 0, 0},  {&_swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t, _p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_SwapSpreadIndex, _p_SwapSpreadIndexTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_Bkbm5M, _p_Bkbm5MTo_p_Observable, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t, _p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_tTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_1Y, _p_Euribor365_1YTo_p_Observable, 0, 0},  {&_swigt__p_YearOnYearInflationSwapHelper, _p_YearOnYearInflationSwapHelperTo_p_Observable, 0, 0},  {&_swigt__p_ZeroCouponInflationSwapHelper, _p_ZeroCouponInflationSwapHelperTo_p_Observable, 0, 0},  {&_swigt__p_YoYOptionletHelper, _p_YoYOptionletHelperTo_p_Observable, 0, 0},  {&_swigt__p_BondHelper, _p_BondHelperTo_p_Observable, 0, 0},  {&_swigt__p_FixedRateBondHelper, _p_FixedRateBondHelperTo_p_Observable, 0, 0},  {&_swigt__p_RateHelper, _p_RateHelperTo_p_Observable, 0, 0},  {&_swigt__p_DepositRateHelper, _p_DepositRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_FraRateHelper, _p_FraRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_FuturesRateHelper, _p_FuturesRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_SwapRateHelper, _p_SwapRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_OISRateHelper, _p_OISRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_DatedOISRateHelper, _p_DatedOISRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_FxSwapRateHelper, _p_FxSwapRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_OvernightIndexFutureRateHelper, _p_OvernightIndexFutureRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_SofrFutureRateHelper, _p_SofrFutureRateHelperTo_p_Observable, 0, 0},  {&_swigt__p_DefaultProbabilityHelper, _p_DefaultProbabilityHelperTo_p_Observable, 0, 0},  {&_swigt__p_SpreadCdsHelper, _p_SpreadCdsHelperTo_p_Observable, 0, 0},  {&_swigt__p_UpfrontCdsHelper, _p_UpfrontCdsHelperTo_p_Observable, 0, 0},  {&_swigt__p_Euribor9M, _p_Euribor9MTo_p_Observable, 0, 0},  {&_swigt__p_Bibor9M, _p_Bibor9MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor9M, _p_EURLibor9MTo_p_Observable, 0, 0},  {&_swigt__p_Bbsw, _p_BbswTo_p_Observable, 0, 0},  {&_swigt__p_AUCPI, _p_AUCPITo_p_Observable, 0, 0},  {&_swigt__p_InflationIndex, _p_InflationIndexTo_p_Observable, 0, 0},  {&_swigt__p_ZeroInflationIndex, _p_ZeroInflationIndexTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationIndex, _p_YoYInflationIndexTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_2M, _p_Euribor365_2MTo_p_Observable, 0, 0},  {&_swigt__p_TermStructureConsistentModel, _p_TermStructureConsistentModelTo_p_Observable, 0, 0},  {&_swigt__p_AnalyticDiscreteGeometricAveragePriceAsianEngine, _p_AnalyticDiscreteGeometricAveragePriceAsianEngineTo_p_Observable, 0, 0},  {&_swigt__p_FedFunds, _p_FedFundsTo_p_Observable, 0, 0},  {&_swigt__p_Quote, _p_QuoteTo_p_Observable, 0, 0},  {&_swigt__p_Vasicek, _p_VasicekTo_p_Observable, 0, 0},  {&_swigt__p_Bkbm6M, _p_Bkbm6MTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_2W, _p_Euribor365_2WTo_p_Observable, 0, 0},  {&_swigt__p_Eonia, _p_EoniaTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_MCHimalayaEngineT_LowDiscrepancy_t, _p_MCHimalayaEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEverestEngineT_LowDiscrepancy_t, _p_MCEverestEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCAmericanBasketEngineT_LowDiscrepancy_t, _p_MCAmericanBasketEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanBasketEngineT_LowDiscrepancy_t, _p_MCEuropeanBasketEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t, _p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanHestonEngineT_LowDiscrepancy_t, _p_MCEuropeanHestonEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCAmericanEngineT_LowDiscrepancy_t, _p_MCAmericanEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCEuropeanEngineT_LowDiscrepancy_t, _p_MCEuropeanEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCBarrierEngineT_LowDiscrepancy_t, _p_MCBarrierEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t, _p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t, _p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t, _p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedDefaultDensityCurveT_Linear_t, _p_InterpolatedDefaultDensityCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedSurvivalProbabilityCurveT_Linear_t, _p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseZeroInflationCurveT_Linear_t, _p_PiecewiseZeroInflationCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroInflationCurveT_Linear_t, _p_InterpolatedZeroInflationCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_PiecewiseYoYInflationCurveT_Linear_t, _p_PiecewiseYoYInflationCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedYoYInflationCurveT_Linear_t, _p_InterpolatedYoYInflationCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_LogLinear_t, _p_InterpolatedDiscountCurveT_LogLinear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_Linear_t, _p_InterpolatedZeroCurveT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_LogLinear_t, _p_InterpolatedZeroCurveT_LogLinear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_Linear_t, _p_InterpolatedSmileSectionT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t, _p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_tTo_p_Observable, 0, 0},  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t, _p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_tTo_p_Observable, 0, 0},  {&_swigt__p_THBFIX, _p_THBFIXTo_p_Observable, 0, 0},  {&_swigt__p_FRHICP, _p_FRHICPTo_p_Observable, 0, 0},  {&_swigt__p_YYFRHICP, _p_YYFRHICPTo_p_Observable, 0, 0},  {&_swigt__p_YYUKRPI, _p_YYUKRPITo_p_Observable, 0, 0},  {&_swigt__p_AnalyticContinuousGeometricAveragePriceAsianEngine, _p_AnalyticContinuousGeometricAveragePriceAsianEngineTo_p_Observable, 0, 0},  {&_swigt__p_USCPI, _p_USCPITo_p_Observable, 0, 0},  {&_swigt__p_CapFloor, _p_CapFloorTo_p_Observable, 0, 0},  {&_swigt__p_YoYInflationCapFloor, _p_YoYInflationCapFloorTo_p_Observable, 0, 0},  {&_swigt__p_FractionalDividend, _p_FractionalDividendTo_p_Observable, 0, 0},  {&_swigt__p_FixedDividend, _p_FixedDividendTo_p_Observable, 0, 0},  {&_swigt__p_Dividend, _p_DividendTo_p_Observable, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_CoxRossRubinstein_t, _p_BinomialConvertibleEngineT_CoxRossRubinstein_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_CoxRossRubinstein_t, _p_BinomialVanillaEngineT_CoxRossRubinstein_tTo_p_Observable, 0, 0},  {&_swigt__p_StrippedOptionletAdapter, _p_StrippedOptionletAdapterTo_p_Observable, 0, 0},  {&_swigt__p_AndreasenHugeLocalVolAdapter, _p_AndreasenHugeLocalVolAdapterTo_p_Observable, 0, 0},  {&_swigt__p_AndreasenHugeVolatilityAdapter, _p_AndreasenHugeVolatilityAdapterTo_p_Observable, 0, 0},  {&_swigt__p_ForwardRateAgreement, _p_ForwardRateAgreementTo_p_Observable, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t, _p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_tTo_p_Observable, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t, _p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365, _p_Euribor365To_p_Observable, 0, 0},  {&_swigt__p_BatesModel, _p_BatesModelTo_p_Observable, 0, 0},  {&_swigt__p_USDLiborON, _p_USDLiborONTo_p_Observable, 0, 0},  {&_swigt__p_GBPLiborON, _p_GBPLiborONTo_p_Observable, 0, 0},  {&_swigt__p_CADLiborON, _p_CADLiborONTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_3M, _p_Euribor365_3MTo_p_Observable, 0, 0},  {&_swigt__p_DailyTenorLibor, _p_DailyTenorLiborTo_p_Observable, 0, 0},  {&_swigt__p_TRLibor, _p_TRLiborTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor, _p_EURLiborTo_p_Observable, 0, 0},  {&_swigt__p_Tibor, _p_TiborTo_p_Observable, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_tTo_p_Observable, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t, _p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_tTo_p_Observable, 0, 0},  {&_swigt__p_AssetSwap, _p_AssetSwapTo_p_Observable, 0, 0},  {&_swigt__p_Swap, _p_SwapTo_p_Observable, 0, 0},  {&_swigt__p_GJRGARCHModel, _p_GJRGARCHModelTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_3W, _p_Euribor365_3WTo_p_Observable, 0, 0},  {&_swigt__p_Bkbm, _p_BkbmTo_p_Observable, 0, 0},  {&_swigt__p_Euribor, _p_EuriborTo_p_Observable, 0, 0},  {&_swigt__p_SwaptionVolatilityCube, _p_SwaptionVolatilityCubeTo_p_Observable, 0, 0},  {&_swigt__p_Cap, _p_CapTo_p_Observable, 0, 0},  {&_swigt__p_YYZACPIr, _p_YYZACPIrTo_p_Observable, 0, 0},  {&_swigt__p_Euribor365_10M, _p_Euribor365_10MTo_p_Observable, 0, 0},  {&_swigt__p_YYZACPI, _p_YYZACPITo_p_Observable, 0, 0},  {&_swigt__p_Euribor1M, _p_Euribor1MTo_p_Observable, 0, 0},  {&_swigt__p_Bibor1M, _p_Bibor1MTo_p_Observable, 0, 0},  {&_swigt__p_EURLibor1M, _p_EURLibor1MTo_p_Observable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OneAssetOption[] = {  {&_swigt__p_VanillaOption, _p_VanillaOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_ForwardVanillaOption, _p_ForwardVanillaOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_QuantoVanillaOption, _p_QuantoVanillaOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_QuantoForwardVanillaOption, _p_QuantoForwardVanillaOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_DividendVanillaOption, _p_DividendVanillaOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_VanillaSwingOption, _p_VanillaSwingOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_BarrierOption, _p_BarrierOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_DividendBarrierOption, _p_DividendBarrierOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_ContinuousAveragingAsianOption, _p_ContinuousAveragingAsianOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_DiscreteAveragingAsianOption, _p_DiscreteAveragingAsianOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_DoubleBarrierOption, _p_DoubleBarrierOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_QuantoDoubleBarrierOption, _p_QuantoDoubleBarrierOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_EuropeanOption, _p_EuropeanOptionTo_p_OneAssetOption, 0, 0},  {&_swigt__p_OneAssetOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OneFactorAffineModel[] = {  {&_swigt__p_OneFactorAffineModel, 0, 0, 0},  {&_swigt__p_Vasicek, _p_VasicekTo_p_OneFactorAffineModel, 0, 0},  {&_swigt__p_HullWhite, _p_HullWhiteTo_p_OneFactorAffineModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OptimizationMethod[] = {  {&_swigt__p_LevenbergMarquardt, _p_LevenbergMarquardtTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_DifferentialEvolution, _p_DifferentialEvolutionTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_GaussianSimulatedAnnealing, _p_GaussianSimulatedAnnealingTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_MirrorGaussianSimulatedAnnealing, _p_MirrorGaussianSimulatedAnnealingTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_LogNormalSimulatedAnnealing, _p_LogNormalSimulatedAnnealingTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_OptimizationMethod, 0, 0, 0},  {&_swigt__p_Simplex, _p_SimplexTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_SteepestDescent, _p_SteepestDescentTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_BFGS, _p_BFGSTo_p_OptimizationMethod, 0, 0},  {&_swigt__p_ConjugateGradient, _p_ConjugateGradientTo_p_OptimizationMethod, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Optimizer[] = {  {&_swigt__p_Optimizer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Option[] = {  {&_swigt__p_Swaption, _p_SwaptionTo_p_Option, 0, 0},  {&_swigt__p_DividendVanillaOption, _p_DividendVanillaOptionTo_p_Option, 0, 0},  {&_swigt__p_QuantoVanillaOption, _p_QuantoVanillaOptionTo_p_Option, 0, 0},  {&_swigt__p_QuantoForwardVanillaOption, _p_QuantoForwardVanillaOptionTo_p_Option, 0, 0},  {&_swigt__p_ForwardVanillaOption, _p_ForwardVanillaOptionTo_p_Option, 0, 0},  {&_swigt__p_VanillaOption, _p_VanillaOptionTo_p_Option, 0, 0},  {&_swigt__p_VanillaSwingOption, _p_VanillaSwingOptionTo_p_Option, 0, 0},  {&_swigt__p_HimalayaOption, _p_HimalayaOptionTo_p_Option, 0, 0},  {&_swigt__p_CdsOption, _p_CdsOptionTo_p_Option, 0, 0},  {&_swigt__p_Option, 0, 0, 0},  {&_swigt__p_DoubleBarrierOption, _p_DoubleBarrierOptionTo_p_Option, 0, 0},  {&_swigt__p_DiscreteAveragingAsianOption, _p_DiscreteAveragingAsianOptionTo_p_Option, 0, 0},  {&_swigt__p_ContinuousAveragingAsianOption, _p_ContinuousAveragingAsianOptionTo_p_Option, 0, 0},  {&_swigt__p_EuropeanOption, _p_EuropeanOptionTo_p_Option, 0, 0},  {&_swigt__p_QuantoDoubleBarrierOption, _p_QuantoDoubleBarrierOptionTo_p_Option, 0, 0},  {&_swigt__p_DividendBarrierOption, _p_DividendBarrierOptionTo_p_Option, 0, 0},  {&_swigt__p_BarrierOption, _p_BarrierOptionTo_p_Option, 0, 0},  {&_swigt__p_MultiAssetOption, _p_MultiAssetOptionTo_p_Option, 0, 0},  {&_swigt__p_SpreadOption, _p_SpreadOptionTo_p_Option, 0, 0},  {&_swigt__p_BasketOption, _p_BasketOptionTo_p_Option, 0, 0},  {&_swigt__p_EverestOption, _p_EverestOptionTo_p_Option, 0, 0},  {&_swigt__p_OneAssetOption, _p_OneAssetOptionTo_p_Option, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OptionletStripper1[] = {  {&_swigt__p_OptionletStripper1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OptionletVolatilityStructure[] = {  {&_swigt__p_OptionletVolatilityStructure, 0, 0, 0},  {&_swigt__p_ConstantOptionletVolatility, _p_ConstantOptionletVolatilityTo_p_OptionletVolatilityStructure, 0, 0},  {&_swigt__p_StrippedOptionletAdapter, _p_StrippedOptionletAdapterTo_p_OptionletVolatilityStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OrnsteinUhlenbeckProcess[] = {  {&_swigt__p_OrnsteinUhlenbeckProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OvernightIndex[] = {  {&_swigt__p_Sofr, _p_SofrTo_p_OvernightIndex, 0, 0},  {&_swigt__p_Aonia, _p_AoniaTo_p_OvernightIndex, 0, 0},  {&_swigt__p_Eonia, _p_EoniaTo_p_OvernightIndex, 0, 0},  {&_swigt__p_Sonia, _p_SoniaTo_p_OvernightIndex, 0, 0},  {&_swigt__p_Nzocr, _p_NzocrTo_p_OvernightIndex, 0, 0},  {&_swigt__p_OvernightIndex, 0, 0, 0},  {&_swigt__p_FedFunds, _p_FedFundsTo_p_OvernightIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OvernightIndexFuture[] = {  {&_swigt__p_OvernightIndexFuture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OvernightIndexFutureRateHelper[] = {  {&_swigt__p_OvernightIndexFutureRateHelper, 0, 0, 0},  {&_swigt__p_SofrFutureRateHelper, _p_SofrFutureRateHelperTo_p_OvernightIndexFutureRateHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OvernightIndexedCoupon[] = {  {&_swigt__p_OvernightIndexedCoupon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OvernightIndexedSwap[] = {  {&_swigt__p_OvernightIndexedSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OvernightIndexedSwapIndex[] = {  {&_swigt__p_OvernightIndexedSwapIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Parameter[] = {  {&_swigt__p_Parameter, 0, 0, 0},  {&_swigt__p_ConstantParameter, _p_ConstantParameterTo_p_Parameter, 0, 0},  {&_swigt__p_NullParameter, _p_NullParameterTo_p_Parameter, 0, 0},  {&_swigt__p_PiecewiseConstantParameter, _p_PiecewiseConstantParameterTo_p_Parameter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParkinsonSigma[] = {  {&_swigt__p_ParkinsonSigma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Path[] = {  {&_swigt__p_Path, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t[] = {  {&_swigt__p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PathGeneratorT_GaussianRandomSequenceGenerator_t[] = {  {&_swigt__p_PathGeneratorT_GaussianRandomSequenceGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t[] = {  {&_swigt__p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Payoff[] = {  {&_swigt__p_SuperSharePayoff, _p_SuperSharePayoffTo_p_Payoff, 0, 0},  {&_swigt__p_AssetOrNothingPayoff, _p_AssetOrNothingPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_CashOrNothingPayoff, _p_CashOrNothingPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_PercentageStrikePayoff, _p_PercentageStrikePayoffTo_p_Payoff, 0, 0},  {&_swigt__p_PlainVanillaPayoff, _p_PlainVanillaPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_StrikedTypePayoff, _p_StrikedTypePayoffTo_p_Payoff, 0, 0},  {&_swigt__p_TypePayoff, _p_TypePayoffTo_p_Payoff, 0, 0},  {&_swigt__p_Payoff, 0, 0, 0},  {&_swigt__p_AverageBasketPayoff, _p_AverageBasketPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_MaxBasketPayoff, _p_MaxBasketPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_MinBasketPayoff, _p_MinBasketPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_BasketPayoff, _p_BasketPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_VanillaForwardPayoff, _p_VanillaForwardPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_GapPayoff, _p_GapPayoffTo_p_Payoff, 0, 0},  {&_swigt__p_SpreadBasketPayoff, _p_SpreadBasketPayoffTo_p_Payoff, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PercentageStrikePayoff[] = {  {&_swigt__p_PercentageStrikePayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Period[] = {  {&_swigt__p_Period, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PeriodParser[] = {  {&_swigt__p_PeriodParser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseConstantParameter[] = {  {&_swigt__p_PiecewiseConstantParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseConvexMonotoneZero[] = {  {&_swigt__p_PiecewiseConvexMonotoneZero, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseCubicZero[] = {  {&_swigt__p_PiecewiseCubicZero, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseFlatForward[] = {  {&_swigt__p_PiecewiseFlatForward, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseFlatHazardRate[] = {  {&_swigt__p_PiecewiseFlatHazardRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseKrugerLogDiscount[] = {  {&_swigt__p_PiecewiseKrugerLogDiscount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseKrugerZero[] = {  {&_swigt__p_PiecewiseKrugerZero, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseLinearForward[] = {  {&_swigt__p_PiecewiseLinearForward, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseLinearZero[] = {  {&_swigt__p_PiecewiseLinearZero, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseLogCubicDiscount[] = {  {&_swigt__p_PiecewiseLogCubicDiscount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseLogLinearDiscount[] = {  {&_swigt__p_PiecewiseLogLinearDiscount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseSplineCubicDiscount[] = {  {&_swigt__p_PiecewiseSplineCubicDiscount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseTimeDependentHestonModel[] = {  {&_swigt__p_PiecewiseTimeDependentHestonModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseYoYInflationCurveT_Linear_t[] = {  {&_swigt__p_PiecewiseYoYInflationCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PiecewiseZeroInflationCurveT_Linear_t[] = {  {&_swigt__p_PiecewiseZeroInflationCurveT_Linear_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pillar[] = {  {&_swigt__p_Pillar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PlainVanillaPayoff[] = {  {&_swigt__p_PlainVanillaPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PoissonDistribution[] = {  {&_swigt__p_PoissonDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Position[] = {  {&_swigt__p_Position, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PositiveConstraint[] = {  {&_swigt__p_PositiveConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Predefined1dMesher[] = {  {&_swigt__p_Predefined1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pribor[] = {  {&_swigt__p_Pribor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PricingEngine[] = {  {&_swigt__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t, _p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdHestonRebateEngine, _p_FdHestonRebateEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdBlackScholesRebateEngine, _p_FdBlackScholesRebateEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdSabrVanillaEngine, _p_FdSabrVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdCEVVanillaEngine, _p_FdCEVVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdHestonVanillaEngine, _p_FdHestonVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdBatesVanillaEngine, _p_FdBatesVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdOrnsteinUhlenbeckVanillaEngine, _p_FdOrnsteinUhlenbeckVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdBlackScholesVanillaEngine, _p_FdBlackScholesVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BatesEngine, _p_BatesEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_PricingEngine, 0, 0, 0},  {&_swigt__p_VarianceGammaEngine, _p_VarianceGammaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FFTVarianceGammaEngine, _p_FFTVarianceGammaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_ContinuousArithmeticAsianLevyEngine, _p_ContinuousArithmeticAsianLevyEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDigitalAmericanKOEngine, _p_AnalyticDigitalAmericanKOEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDoubleBarrierBinaryEngine, _p_AnalyticDoubleBarrierBinaryEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdSimpleBSSwingEngine, _p_FdSimpleBSSwingEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdSimpleExtOUJumpSwingEngine, _p_FdSimpleExtOUJumpSwingEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_KirkEngine, _p_KirkEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_Fd2dBlackScholesVanillaEngine, _p_Fd2dBlackScholesVanillaEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticBSMHullWhiteEngine, _p_AnalyticBSMHullWhiteEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_MidPointCdsEngine, _p_MidPointCdsEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_IntegralCdsEngine, _p_IntegralCdsEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_IsdaCdsEngine, _p_IsdaCdsEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_LeisenReimer_t, _p_BinomialVanillaEngineT_LeisenReimer_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_LeisenReimer_t, _p_BinomialConvertibleEngineT_LeisenReimer_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine, _p_AnalyticDiscreteGeometricAverageStrikeAsianEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t, _p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDiscreteGeometricAveragePriceAsianEngine, _p_AnalyticDiscreteGeometricAveragePriceAsianEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_JarrowRudd_t, _p_BinomialConvertibleEngineT_JarrowRudd_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_JarrowRudd_t, _p_BinomialVanillaEngineT_JarrowRudd_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t, _p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_Trigeorgis_t, _p_BinomialConvertibleEngineT_Trigeorgis_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_Trigeorgis_t, _p_BinomialVanillaEngineT_Trigeorgis_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCHimalayaEngineT_PseudoRandom_t, _p_MCHimalayaEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEverestEngineT_PseudoRandom_t, _p_MCEverestEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCAmericanBasketEngineT_PseudoRandom_t, _p_MCAmericanBasketEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanBasketEngineT_PseudoRandom_t, _p_MCEuropeanBasketEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t, _p_MCEuropeanGJRGARCHEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanHestonEngineT_PseudoRandom_t, _p_MCEuropeanHestonEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCAmericanEngineT_PseudoRandom_t, _p_MCAmericanEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanEngineT_PseudoRandom_t, _p_MCEuropeanEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCBarrierEngineT_PseudoRandom_t, _p_MCBarrierEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t, _p_MCDiscreteArithmeticAPEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t, _p_MCDiscreteArithmeticASEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t, _p_MCDiscreteGeometricAPEngineT_PseudoRandom_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_Tian_t, _p_BinomialConvertibleEngineT_Tian_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_Tian_t, _p_BinomialVanillaEngineT_Tian_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticContinuousGeometricAveragePriceAsianEngine, _p_AnalyticContinuousGeometricAveragePriceAsianEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdHestonBarrierEngine, _p_FdHestonBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdBlackScholesBarrierEngine, _p_FdBlackScholesBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticCEVEngine, _p_AnalyticCEVEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticBarrierEngine, _p_AnalyticBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_IntegralEngine, _p_IntegralEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticPTDHestonEngine, _p_AnalyticPTDHestonEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_ExponentialFittingHestonEngine, _p_ExponentialFittingHestonEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_COSHestonEngine, _p_COSHestonEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticHestonEngine, _p_AnalyticHestonEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticEuropeanEngine, _p_AnalyticEuropeanEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdBlackScholesAsianEngine, _p_FdBlackScholesAsianEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BaroneAdesiWhaleyApproximationEngine, _p_BaroneAdesiWhaleyApproximationEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BjerksundStenslandApproximationEngine, _p_BjerksundStenslandApproximationEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_JuQuadraticApproximationEngine, _p_JuQuadraticApproximationEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDigitalAmericanEngine, _p_AnalyticDigitalAmericanEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDividendEuropeanEngine, _p_AnalyticDividendEuropeanEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticBinaryBarrierEngine, _p_AnalyticBinaryBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_ForwardEuropeanEngine, _p_ForwardEuropeanEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_QuantoEuropeanEngine, _p_QuantoEuropeanEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_QuantoForwardEuropeanEngine, _p_QuantoForwardEuropeanEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticDoubleBarrierEngine, _p_AnalyticDoubleBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdHestonDoubleBarrierEngine, _p_FdHestonDoubleBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_WulinYongDoubleBarrierEngine, _p_WulinYongDoubleBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_VannaVolgaBarrierEngine, _p_VannaVolgaBarrierEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticGJRGARCHEngine, _p_AnalyticGJRGARCHEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_KirkSpreadOptionEngine, _p_KirkSpreadOptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_StulzEngine, _p_StulzEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_DiscountingSwapEngine, _p_DiscountingSwapEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_YoYInflationBlackCapFloorEngine, _p_YoYInflationBlackCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_YoYInflationUnitDisplacedBlackCapFloorEngine, _p_YoYInflationUnitDisplacedBlackCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_YoYInflationBachelierCapFloorEngine, _p_YoYInflationBachelierCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_JamshidianSwaptionEngine, _p_JamshidianSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_TreeSwaptionEngine, _p_TreeSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_AnalyticCapFloorEngine, _p_AnalyticCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_TreeCapFloorEngine, _p_TreeCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_G2SwaptionEngine, _p_G2SwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdG2SwaptionEngine, _p_FdG2SwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_FdHullWhiteSwaptionEngine, _p_FdHullWhiteSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_DiscountingBondEngine, _p_DiscountingBondEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_TreeCallableFixedRateBondEngine, _p_TreeCallableFixedRateBondEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BlackCallableFixedRateBondEngine, _p_BlackCallableFixedRateBondEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BlackCapFloorEngine, _p_BlackCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BachelierCapFloorEngine, _p_BachelierCapFloorEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BlackCdsOptionEngine, _p_BlackCdsOptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_Gaussian1dSwaptionEngine, _p_Gaussian1dSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_Gaussian1dJamshidianSwaptionEngine, _p_Gaussian1dJamshidianSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_Gaussian1dNonstandardSwaptionEngine, _p_Gaussian1dNonstandardSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_Gaussian1dFloatFloatSwaptionEngine, _p_Gaussian1dFloatFloatSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BlackSwaptionEngine, _p_BlackSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BachelierSwaptionEngine, _p_BachelierSwaptionEngineTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_Joshi4_t, _p_BinomialVanillaEngineT_Joshi4_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_Joshi4_t, _p_BinomialConvertibleEngineT_Joshi4_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialConvertibleEngineT_CoxRossRubinstein_t, _p_BinomialConvertibleEngineT_CoxRossRubinstein_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialVanillaEngineT_CoxRossRubinstein_t, _p_BinomialVanillaEngineT_CoxRossRubinstein_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t, _p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t, _p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FDEuropeanEngineT_CrankNicolson_t, _p_FDEuropeanEngineT_CrankNicolson_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FDBermudanEngineT_CrankNicolson_t, _p_FDBermudanEngineT_CrankNicolson_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FDAmericanEngineT_CrankNicolson_t, _p_FDAmericanEngineT_CrankNicolson_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FDShoutEngineT_CrankNicolson_t, _p_FDShoutEngineT_CrankNicolson_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FDDividendEuropeanEngineT_CrankNicolson_t, _p_FDDividendEuropeanEngineT_CrankNicolson_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_FDDividendAmericanEngineT_CrankNicolson_t, _p_FDDividendAmericanEngineT_CrankNicolson_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t, _p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCHimalayaEngineT_LowDiscrepancy_t, _p_MCHimalayaEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEverestEngineT_LowDiscrepancy_t, _p_MCEverestEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCAmericanBasketEngineT_LowDiscrepancy_t, _p_MCAmericanBasketEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanBasketEngineT_LowDiscrepancy_t, _p_MCEuropeanBasketEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t, _p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanHestonEngineT_LowDiscrepancy_t, _p_MCEuropeanHestonEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCAmericanEngineT_LowDiscrepancy_t, _p_MCAmericanEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCEuropeanEngineT_LowDiscrepancy_t, _p_MCEuropeanEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCBarrierEngineT_LowDiscrepancy_t, _p_MCBarrierEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t, _p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t, _p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},  {&_swigt__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t, _p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_tTo_p_PricingEngine, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ProbabilityBoltzmannDownhill[] = {  {&_swigt__p_ProbabilityBoltzmannDownhill, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Protection[] = {  {&_swigt__p_Protection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PyObserver[] = {  {&_swigt__p_PyObserver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ARSCurrency[] = {  {&_swigt__p_QuantLib__ARSCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ATSCurrency[] = {  {&_swigt__p_QuantLib__ATSCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__AUDCurrency[] = {  {&_swigt__p_QuantLib__AUDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Actual360[] = {  {&_swigt__p_QuantLib__Actual360, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Actual364[] = {  {&_swigt__p_QuantLib__Actual364, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Actual365Fixed[] = {  {&_swigt__p_QuantLib__Actual365Fixed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ActualActual[] = {  {&_swigt__p_QuantLib__ActualActual, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Argentina[] = {  {&_swigt__p_QuantLib__Argentina, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Australia[] = {  {&_swigt__p_QuantLib__Australia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__BDTCurrency[] = {  {&_swigt__p_QuantLib__BDTCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__BEFCurrency[] = {  {&_swigt__p_QuantLib__BEFCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__BGLCurrency[] = {  {&_swigt__p_QuantLib__BGLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__BRLCurrency[] = {  {&_swigt__p_QuantLib__BRLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__BYRCurrency[] = {  {&_swigt__p_QuantLib__BYRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__BespokeCalendar[] = {  {&_swigt__p_QuantLib__BespokeCalendar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Brazil[] = {  {&_swigt__p_QuantLib__Brazil, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Business252[] = {  {&_swigt__p_QuantLib__Business252, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CADCurrency[] = {  {&_swigt__p_QuantLib__CADCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CHFCurrency[] = {  {&_swigt__p_QuantLib__CHFCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CLPCurrency[] = {  {&_swigt__p_QuantLib__CLPCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CNYCurrency[] = {  {&_swigt__p_QuantLib__CNYCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__COPCurrency[] = {  {&_swigt__p_QuantLib__COPCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CYPCurrency[] = {  {&_swigt__p_QuantLib__CYPCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CZKCurrency[] = {  {&_swigt__p_QuantLib__CZKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Canada[] = {  {&_swigt__p_QuantLib__Canada, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__China[] = {  {&_swigt__p_QuantLib__China, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__CzechRepublic[] = {  {&_swigt__p_QuantLib__CzechRepublic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__DEMCurrency[] = {  {&_swigt__p_QuantLib__DEMCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__DKKCurrency[] = {  {&_swigt__p_QuantLib__DKKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Denmark[] = {  {&_swigt__p_QuantLib__Denmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__EEKCurrency[] = {  {&_swigt__p_QuantLib__EEKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ESPCurrency[] = {  {&_swigt__p_QuantLib__ESPCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__EURCurrency[] = {  {&_swigt__p_QuantLib__EURCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__FIMCurrency[] = {  {&_swigt__p_QuantLib__FIMCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__FRFCurrency[] = {  {&_swigt__p_QuantLib__FRFCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Finland[] = {  {&_swigt__p_QuantLib__Finland, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__France[] = {  {&_swigt__p_QuantLib__France, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__GBPCurrency[] = {  {&_swigt__p_QuantLib__GBPCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__GRDCurrency[] = {  {&_swigt__p_QuantLib__GRDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Germany[] = {  {&_swigt__p_QuantLib__Germany, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__HKDCurrency[] = {  {&_swigt__p_QuantLib__HKDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__HUFCurrency[] = {  {&_swigt__p_QuantLib__HUFCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__HongKong[] = {  {&_swigt__p_QuantLib__HongKong, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Hungary[] = {  {&_swigt__p_QuantLib__Hungary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__IDRCurrency[] = {  {&_swigt__p_QuantLib__IDRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__IEPCurrency[] = {  {&_swigt__p_QuantLib__IEPCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ILSCurrency[] = {  {&_swigt__p_QuantLib__ILSCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__INRCurrency[] = {  {&_swigt__p_QuantLib__INRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__IQDCurrency[] = {  {&_swigt__p_QuantLib__IQDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__IRRCurrency[] = {  {&_swigt__p_QuantLib__IRRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ISKCurrency[] = {  {&_swigt__p_QuantLib__ISKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ITLCurrency[] = {  {&_swigt__p_QuantLib__ITLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Iceland[] = {  {&_swigt__p_QuantLib__Iceland, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__India[] = {  {&_swigt__p_QuantLib__India, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Indonesia[] = {  {&_swigt__p_QuantLib__Indonesia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Israel[] = {  {&_swigt__p_QuantLib__Israel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Italy[] = {  {&_swigt__p_QuantLib__Italy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__JPYCurrency[] = {  {&_swigt__p_QuantLib__JPYCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Japan[] = {  {&_swigt__p_QuantLib__Japan, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__JointCalendar[] = {  {&_swigt__p_QuantLib__JointCalendar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__KRWCurrency[] = {  {&_swigt__p_QuantLib__KRWCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__KWDCurrency[] = {  {&_swigt__p_QuantLib__KWDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__LTLCurrency[] = {  {&_swigt__p_QuantLib__LTLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__LUFCurrency[] = {  {&_swigt__p_QuantLib__LUFCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__LVLCurrency[] = {  {&_swigt__p_QuantLib__LVLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__MTLCurrency[] = {  {&_swigt__p_QuantLib__MTLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__MXNCurrency[] = {  {&_swigt__p_QuantLib__MXNCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__MYRCurrency[] = {  {&_swigt__p_QuantLib__MYRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Mexico[] = {  {&_swigt__p_QuantLib__Mexico, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__NLGCurrency[] = {  {&_swigt__p_QuantLib__NLGCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__NOKCurrency[] = {  {&_swigt__p_QuantLib__NOKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__NPRCurrency[] = {  {&_swigt__p_QuantLib__NPRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__NZDCurrency[] = {  {&_swigt__p_QuantLib__NZDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__NewZealand[] = {  {&_swigt__p_QuantLib__NewZealand, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Norway[] = {  {&_swigt__p_QuantLib__Norway, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__NullCalendar[] = {  {&_swigt__p_QuantLib__NullCalendar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__OneDayCounter[] = {  {&_swigt__p_QuantLib__OneDayCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__PEHCurrency[] = {  {&_swigt__p_QuantLib__PEHCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__PEICurrency[] = {  {&_swigt__p_QuantLib__PEICurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__PENCurrency[] = {  {&_swigt__p_QuantLib__PENCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__PKRCurrency[] = {  {&_swigt__p_QuantLib__PKRCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__PLNCurrency[] = {  {&_swigt__p_QuantLib__PLNCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__PTECurrency[] = {  {&_swigt__p_QuantLib__PTECurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Poland[] = {  {&_swigt__p_QuantLib__Poland, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ROLCurrency[] = {  {&_swigt__p_QuantLib__ROLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__RONCurrency[] = {  {&_swigt__p_QuantLib__RONCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__RUBCurrency[] = {  {&_swigt__p_QuantLib__RUBCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Romania[] = {  {&_swigt__p_QuantLib__Romania, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Russia[] = {  {&_swigt__p_QuantLib__Russia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SARCurrency[] = {  {&_swigt__p_QuantLib__SARCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SEKCurrency[] = {  {&_swigt__p_QuantLib__SEKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SGDCurrency[] = {  {&_swigt__p_QuantLib__SGDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SITCurrency[] = {  {&_swigt__p_QuantLib__SITCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SKKCurrency[] = {  {&_swigt__p_QuantLib__SKKCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SaudiArabia[] = {  {&_swigt__p_QuantLib__SaudiArabia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SimpleDayCounter[] = {  {&_swigt__p_QuantLib__SimpleDayCounter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Singapore[] = {  {&_swigt__p_QuantLib__Singapore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Slovakia[] = {  {&_swigt__p_QuantLib__Slovakia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SouthAfrica[] = {  {&_swigt__p_QuantLib__SouthAfrica, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__SouthKorea[] = {  {&_swigt__p_QuantLib__SouthKorea, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Sweden[] = {  {&_swigt__p_QuantLib__Sweden, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Switzerland[] = {  {&_swigt__p_QuantLib__Switzerland, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__TARGET[] = {  {&_swigt__p_QuantLib__TARGET, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__THBCurrency[] = {  {&_swigt__p_QuantLib__THBCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__TRLCurrency[] = {  {&_swigt__p_QuantLib__TRLCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__TRYCurrency[] = {  {&_swigt__p_QuantLib__TRYCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__TTDCurrency[] = {  {&_swigt__p_QuantLib__TTDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__TWDCurrency[] = {  {&_swigt__p_QuantLib__TWDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Taiwan[] = {  {&_swigt__p_QuantLib__Taiwan, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Thailand[] = {  {&_swigt__p_QuantLib__Thailand, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Thirty360[] = {  {&_swigt__p_QuantLib__Thirty360, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Thirty365[] = {  {&_swigt__p_QuantLib__Thirty365, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Turkey[] = {  {&_swigt__p_QuantLib__Turkey, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__USDCurrency[] = {  {&_swigt__p_QuantLib__USDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__Ukraine[] = {  {&_swigt__p_QuantLib__Ukraine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__UnitedKingdom[] = {  {&_swigt__p_QuantLib__UnitedKingdom, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__UnitedStates[] = {  {&_swigt__p_QuantLib__UnitedStates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__VEBCurrency[] = {  {&_swigt__p_QuantLib__VEBCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__VNDCurrency[] = {  {&_swigt__p_QuantLib__VNDCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__WeekendsOnly[] = {  {&_swigt__p_QuantLib__WeekendsOnly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantLib__ZARCurrency[] = {  {&_swigt__p_QuantLib__ZARCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantoDoubleBarrierOption[] = {  {&_swigt__p_QuantoDoubleBarrierOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantoEuropeanEngine[] = {  {&_swigt__p_QuantoEuropeanEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantoForwardEuropeanEngine[] = {  {&_swigt__p_QuantoForwardEuropeanEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantoForwardVanillaOption[] = {  {&_swigt__p_QuantoForwardVanillaOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuantoVanillaOption[] = {  {&_swigt__p_QuantoVanillaOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Quote[] = {  {&_swigt__p_SimpleQuote, _p_SimpleQuoteTo_p_Quote, 0, 0},  {&_swigt__p_Quote, 0, 0, 0},  {&_swigt__p_DerivedQuoteT_UnaryFunction_t, _p_DerivedQuoteT_UnaryFunction_tTo_p_Quote, 0, 0},  {&_swigt__p_CompositeQuoteT_BinaryFunction_t, _p_CompositeQuoteT_BinaryFunction_tTo_p_Quote, 0, 0},  {&_swigt__p_DeltaVolQuote, _p_DeltaVolQuoteTo_p_Quote, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RandomSequenceGeneratorT_KnuthUniformRng_t[] = {  {&_swigt__p_RandomSequenceGeneratorT_KnuthUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RandomSequenceGeneratorT_LecuyerUniformRng_t[] = {  {&_swigt__p_RandomSequenceGeneratorT_LecuyerUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t[] = {  {&_swigt__p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RateHelper[] = {  {&_swigt__p_BondHelper, _p_BondHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_FixedRateBondHelper, _p_FixedRateBondHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_RateHelper, 0, 0, 0},  {&_swigt__p_DepositRateHelper, _p_DepositRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_FraRateHelper, _p_FraRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_FuturesRateHelper, _p_FuturesRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_SwapRateHelper, _p_SwapRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_OISRateHelper, _p_OISRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_DatedOISRateHelper, _p_DatedOISRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_FxSwapRateHelper, _p_FxSwapRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_OvernightIndexFutureRateHelper, _p_OvernightIndexFutureRateHelperTo_p_RateHelper, 0, 0},  {&_swigt__p_SofrFutureRateHelper, _p_SofrFutureRateHelperTo_p_RateHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RealTimeSeries[] = {  {&_swigt__p_RealTimeSeries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ReannealingTrivial[] = {  {&_swigt__p_ReannealingTrivial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RebatedExercise[] = {  {&_swigt__p_RebatedExercise, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Redemption[] = {  {&_swigt__p_Redemption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Region[] = {  {&_swigt__p_Region, 0, 0, 0},  {&_swigt__p_CustomRegion, _p_CustomRegionTo_p_Region, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_BlackVolTermStructure_t[] = {  {&_swigt__p_RelinkableHandleT_BlackVolTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_CalibratedModel_t[] = {  {&_swigt__p_RelinkableHandleT_CalibratedModel_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_CapFloorTermVolatilityStructure_t[] = {  {&_swigt__p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_DefaultProbabilityTermStructure_t[] = {  {&_swigt__p_RelinkableHandleT_DefaultProbabilityTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_DeltaVolQuote_t[] = {  {&_swigt__p_RelinkableHandleT_DeltaVolQuote_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_LocalVolTermStructure_t[] = {  {&_swigt__p_RelinkableHandleT_LocalVolTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_OptionletVolatilityStructure_t[] = {  {&_swigt__p_RelinkableHandleT_OptionletVolatilityStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_Quote_t[] = {  {&_swigt__p_RelinkableHandleT_Quote_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_ShortRateModel_t[] = {  {&_swigt__p_RelinkableHandleT_ShortRateModel_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_SwaptionVolatilityStructure_t[] = {  {&_swigt__p_RelinkableHandleT_SwaptionVolatilityStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_YieldTermStructure_t[] = {  {&_swigt__p_RelinkableHandleT_YieldTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_YoYInflationTermStructure_t[] = {  {&_swigt__p_RelinkableHandleT_YoYInflationTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_YoYOptionletVolatilitySurface_t[] = {  {&_swigt__p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RelinkableHandleT_ZeroInflationTermStructure_t[] = {  {&_swigt__p_RelinkableHandleT_ZeroInflationTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RichardsonExtrapolation[] = {  {&_swigt__p_RichardsonExtrapolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ridder[] = {  {&_swigt__p_Ridder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RiskNeutralDensityCalculator[] = {  {&_swigt__p_RiskNeutralDensityCalculator, 0, 0, 0},  {&_swigt__p_BSMRNDCalculator, _p_BSMRNDCalculatorTo_p_RiskNeutralDensityCalculator, 0, 0},  {&_swigt__p_CEVRNDCalculator, _p_CEVRNDCalculatorTo_p_RiskNeutralDensityCalculator, 0, 0},  {&_swigt__p_GBSMRNDCalculator, _p_GBSMRNDCalculatorTo_p_RiskNeutralDensityCalculator, 0, 0},  {&_swigt__p_HestonRNDCalculator, _p_HestonRNDCalculatorTo_p_RiskNeutralDensityCalculator, 0, 0},  {&_swigt__p_LocalVolRNDCalculator, _p_LocalVolRNDCalculatorTo_p_RiskNeutralDensityCalculator, 0, 0},  {&_swigt__p_SquareRootProcessRNDCalculator, _p_SquareRootProcessRNDCalculatorTo_p_RiskNeutralDensityCalculator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RiskStatistics[] = {  {&_swigt__p_RiskStatistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Robor[] = {  {&_swigt__p_Robor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Rounding[] = {  {&_swigt__p_CeilingTruncation, _p_CeilingTruncationTo_p_Rounding, 0, 0},  {&_swigt__p_FloorTruncation, _p_FloorTruncationTo_p_Rounding, 0, 0},  {&_swigt__p_Rounding, 0, 0, 0},  {&_swigt__p_UpRounding, _p_UpRoundingTo_p_Rounding, 0, 0},  {&_swigt__p_DownRounding, _p_DownRoundingTo_p_Rounding, 0, 0},  {&_swigt__p_ClosestRounding, _p_ClosestRoundingTo_p_Rounding, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SEKLibor[] = {  {&_swigt__p_SEKLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SVD[] = {  {&_swigt__p_SVD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SabrSmileSection[] = {  {&_swigt__p_SabrSmileSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeBackwardFlatInterpolation[] = {  {&_swigt__p_SafeBackwardFlatInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeBicubicSpline[] = {  {&_swigt__p_SafeBicubicSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeBilinearInterpolation[] = {  {&_swigt__p_SafeBilinearInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeConvexMonotoneInterpolation[] = {  {&_swigt__p_SafeConvexMonotoneInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeCubicNaturalSpline[] = {  {&_swigt__p_SafeCubicNaturalSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeForwardFlatInterpolation[] = {  {&_swigt__p_SafeForwardFlatInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeFritschButlandCubic[] = {  {&_swigt__p_SafeFritschButlandCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeFritschButlandLogCubic[] = {  {&_swigt__p_SafeFritschButlandLogCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeKrugerCubic[] = {  {&_swigt__p_SafeKrugerCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeKrugerLogCubic[] = {  {&_swigt__p_SafeKrugerLogCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeLinearInterpolation[] = {  {&_swigt__p_SafeLinearInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeLogCubicNaturalSpline[] = {  {&_swigt__p_SafeLogCubicNaturalSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeLogLinearInterpolation[] = {  {&_swigt__p_SafeLogLinearInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeLogParabolic[] = {  {&_swigt__p_SafeLogParabolic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeMonotonicCubicNaturalSpline[] = {  {&_swigt__p_SafeMonotonicCubicNaturalSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeMonotonicLogCubicNaturalSpline[] = {  {&_swigt__p_SafeMonotonicLogCubicNaturalSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeMonotonicLogParabolic[] = {  {&_swigt__p_SafeMonotonicLogParabolic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeMonotonicParabolic[] = {  {&_swigt__p_SafeMonotonicParabolic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeParabolic[] = {  {&_swigt__p_SafeParabolic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SafeSABRInterpolation[] = {  {&_swigt__p_SafeSABRInterpolation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SalvagingAlgorithm[] = {  {&_swigt__p_SalvagingAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SampleT_Array_t[] = {  {&_swigt__p_SampleT_Array_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SampleT_MultiPath_t[] = {  {&_swigt__p_SampleT_MultiPath_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SampleT_Path_t[] = {  {&_swigt__p_SampleT_Path_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SampleT_double_t[] = {  {&_swigt__p_SampleT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t[] = {  {&_swigt__p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SampledCurve[] = {  {&_swigt__p_SampledCurve, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SamplerGaussian[] = {  {&_swigt__p_SamplerGaussian, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SamplerLogNormal[] = {  {&_swigt__p_SamplerLogNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SamplerMirrorGaussian[] = {  {&_swigt__p_SamplerMirrorGaussian, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Schedule[] = {  {&_swigt__p_Schedule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Seasonality[] = {  {&_swigt__p_Seasonality, 0, 0, 0},  {&_swigt__p_MultiplicativePriceSeasonality, _p_MultiplicativePriceSeasonalityTo_p_Seasonality, 0, 0},  {&_swigt__p_KerkhofSeasonality, _p_KerkhofSeasonalityTo_p_Seasonality, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Secant[] = {  {&_swigt__p_Secant, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SecondDerivativeOp[] = {  {&_swigt__p_SecondDerivativeOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SecondOrderMixedDerivativeOp[] = {  {&_swigt__p_SecondOrderMixedDerivativeOp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SegmentIntegral[] = {  {&_swigt__p_SegmentIntegral, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Settings[] = {  {&_swigt__p_Settings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Settlement[] = {  {&_swigt__p_Settlement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Shibor[] = {  {&_swigt__p_Shibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShortRateModel[] = {  {&_swigt__p_ShortRateModel, 0, 0, 0},  {&_swigt__p_OneFactorAffineModel, _p_OneFactorAffineModelTo_p_ShortRateModel, 0, 0},  {&_swigt__p_BlackKarasinski, _p_BlackKarasinskiTo_p_ShortRateModel, 0, 0},  {&_swigt__p_G2, _p_G2To_p_ShortRateModel, 0, 0},  {&_swigt__p_Vasicek, _p_VasicekTo_p_ShortRateModel, 0, 0},  {&_swigt__p_CoxIngersollRoss, _p_CoxIngersollRossTo_p_ShortRateModel, 0, 0},  {&_swigt__p_ExtendedCoxIngersollRoss, _p_ExtendedCoxIngersollRossTo_p_ShortRateModel, 0, 0},  {&_swigt__p_HullWhite, _p_HullWhiteTo_p_ShortRateModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Side[] = {  {&_swigt__p_Side, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimpleCashFlow[] = {  {&_swigt__p_SimpleCashFlow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimplePolynomialFitting[] = {  {&_swigt__p_SimplePolynomialFitting, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimpleQuote[] = {  {&_swigt__p_SimpleQuote, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Simplex[] = {  {&_swigt__p_Simplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimpsonIntegral[] = {  {&_swigt__p_SimpsonIntegral, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SmileSection[] = {  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t, _p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_tTo_p_SmileSection, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t, _p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_tTo_p_SmileSection, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t, _p_ZabrSmileSectionT_ZabrShortMaturityNormal_tTo_p_SmileSection, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t, _p_ZabrSmileSectionT_ZabrShortMaturityLognormal_tTo_p_SmileSection, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_SplineCubic_t, _p_InterpolatedSmileSectionT_SplineCubic_tTo_p_SmileSection, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_MonotonicCubic_t, _p_InterpolatedSmileSectionT_MonotonicCubic_tTo_p_SmileSection, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_Cubic_t, _p_InterpolatedSmileSectionT_Cubic_tTo_p_SmileSection, 0, 0},  {&_swigt__p_KahaleSmileSection, _p_KahaleSmileSectionTo_p_SmileSection, 0, 0},  {&_swigt__p_FlatSmileSection, _p_FlatSmileSectionTo_p_SmileSection, 0, 0},  {&_swigt__p_SabrSmileSection, _p_SabrSmileSectionTo_p_SmileSection, 0, 0},  {&_swigt__p_NoArbSabrSmileSection, _p_NoArbSabrSmileSectionTo_p_SmileSection, 0, 0},  {&_swigt__p_NoArbSabrInterpolatedSmileSection, _p_NoArbSabrInterpolatedSmileSectionTo_p_SmileSection, 0, 0},  {&_swigt__p_SmileSection, 0, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t, _p_ZabrInterpolatedSmileSectionT_ZabrFullFd_tTo_p_SmileSection, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrFullFd_t, _p_ZabrSmileSectionT_ZabrFullFd_tTo_p_SmileSection, 0, 0},  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t, _p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_tTo_p_SmileSection, 0, 0},  {&_swigt__p_InterpolatedSmileSectionT_Linear_t, _p_InterpolatedSmileSectionT_Linear_tTo_p_SmileSection, 0, 0},  {&_swigt__p_ZabrSmileSectionT_ZabrLocalVolatility_t, _p_ZabrSmileSectionT_ZabrLocalVolatility_tTo_p_SmileSection, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SobolBrownianBridgeRsg[] = {  {&_swigt__p_SobolBrownianBridgeRsg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SobolBrownianGenerator[] = {  {&_swigt__p_SobolBrownianGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SobolBrownianGeneratorFactory[] = {  {&_swigt__p_SobolBrownianGeneratorFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SobolRsg[] = {  {&_swigt__p_SobolRsg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Sofr[] = {  {&_swigt__p_Sofr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SofrFutureRateHelper[] = {  {&_swigt__p_SofrFutureRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoftCallability[] = {  {&_swigt__p_SoftCallability, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Sonia[] = {  {&_swigt__p_Sonia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SplineCubic[] = {  {&_swigt__p_SplineCubic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpreadBasketPayoff[] = {  {&_swigt__p_SpreadBasketPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpreadCdsHelper[] = {  {&_swigt__p_SpreadCdsHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpreadOption[] = {  {&_swigt__p_SpreadOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SquareRootProcessRNDCalculator[] = {  {&_swigt__p_SquareRootProcessRNDCalculator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Statistics[] = {  {&_swigt__p_Statistics, 0, 0, 0},  {&_swigt__p_RiskStatistics, _p_RiskStatisticsTo_p_Statistics, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SteepestDescent[] = {  {&_swigt__p_SteepestDescent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StepConditionT_Array_t[] = {  {&_swigt__p_FdmSnapshotCondition, _p_FdmSnapshotConditionTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmAmericanStepCondition, _p_FdmAmericanStepConditionTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmArithmeticAverageCondition, _p_FdmArithmeticAverageConditionTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmBermudanStepCondition, _p_FdmBermudanStepConditionTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmSimpleStorageCondition, _p_FdmSimpleStorageConditionTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmSimpleSwingCondition, _p_FdmSimpleSwingConditionTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmStepConditionComposite, _p_FdmStepConditionCompositeTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_FdmDividendHandler, _p_FdmDividendHandlerTo_p_StepConditionT_Array_t, 0, 0},  {&_swigt__p_StepConditionT_Array_t, 0, 0, 0},  {&_swigt__p_FdmStepConditionProxy, _p_FdmStepConditionProxyTo_p_StepConditionT_Array_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StochasticProcess[] = {  {&_swigt__p_StochasticProcessArray, _p_StochasticProcessArrayTo_p_StochasticProcess, 0, 0},  {&_swigt__p_StochasticProcess1D, _p_StochasticProcess1DTo_p_StochasticProcess, 0, 0},  {&_swigt__p_BlackScholesMertonProcess, _p_BlackScholesMertonProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_BlackProcess, _p_BlackProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_GarmanKohlagenProcess, _p_GarmanKohlagenProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_Merton76Process, _p_Merton76ProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_GeometricBrownianMotionProcess, _p_GeometricBrownianMotionProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_VarianceGammaProcess, _p_VarianceGammaProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_HullWhiteProcess, _p_HullWhiteProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_HullWhiteForwardProcess, _p_HullWhiteForwardProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_GsrProcess, _p_GsrProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_OrnsteinUhlenbeckProcess, _p_OrnsteinUhlenbeckProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_ExtendedOrnsteinUhlenbeckProcess, _p_ExtendedOrnsteinUhlenbeckProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_StochasticProcess, 0, 0, 0},  {&_swigt__p_BlackScholesProcess, _p_BlackScholesProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_GeneralizedBlackScholesProcess, _p_GeneralizedBlackScholesProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_HestonProcess, _p_HestonProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_BatesProcess, _p_BatesProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_G2Process, _p_G2ProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_G2ForwardProcess, _p_G2ForwardProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_ExtOUWithJumpsProcess, _p_ExtOUWithJumpsProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_KlugeExtOUProcess, _p_KlugeExtOUProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_GJRGARCHProcess, _p_GJRGARCHProcessTo_p_StochasticProcess, 0, 0},  {&_swigt__p_HestonSLVProcess, _p_HestonSLVProcessTo_p_StochasticProcess, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StochasticProcess1D[] = {  {&_swigt__p_StochasticProcess1D, 0, 0, 0},  {&_swigt__p_GeneralizedBlackScholesProcess, _p_GeneralizedBlackScholesProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_BlackScholesProcess, _p_BlackScholesProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_BlackScholesMertonProcess, _p_BlackScholesMertonProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_BlackProcess, _p_BlackProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_GarmanKohlagenProcess, _p_GarmanKohlagenProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_Merton76Process, _p_Merton76ProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_GeometricBrownianMotionProcess, _p_GeometricBrownianMotionProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_VarianceGammaProcess, _p_VarianceGammaProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_HullWhiteProcess, _p_HullWhiteProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_HullWhiteForwardProcess, _p_HullWhiteForwardProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_GsrProcess, _p_GsrProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_OrnsteinUhlenbeckProcess, _p_OrnsteinUhlenbeckProcessTo_p_StochasticProcess1D, 0, 0},  {&_swigt__p_ExtendedOrnsteinUhlenbeckProcess, _p_ExtendedOrnsteinUhlenbeckProcessTo_p_StochasticProcess1D, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StochasticProcessArray[] = {  {&_swigt__p_StochasticProcessArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Stock[] = {  {&_swigt__p_Stock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StrikedTypePayoff[] = {  {&_swigt__p_StrikedTypePayoff, 0, 0, 0},  {&_swigt__p_PlainVanillaPayoff, _p_PlainVanillaPayoffTo_p_StrikedTypePayoff, 0, 0},  {&_swigt__p_PercentageStrikePayoff, _p_PercentageStrikePayoffTo_p_StrikedTypePayoff, 0, 0},  {&_swigt__p_CashOrNothingPayoff, _p_CashOrNothingPayoffTo_p_StrikedTypePayoff, 0, 0},  {&_swigt__p_AssetOrNothingPayoff, _p_AssetOrNothingPayoffTo_p_StrikedTypePayoff, 0, 0},  {&_swigt__p_SuperSharePayoff, _p_SuperSharePayoffTo_p_StrikedTypePayoff, 0, 0},  {&_swigt__p_GapPayoff, _p_GapPayoffTo_p_StrikedTypePayoff, 0, 0},  {&_swigt__p_VanillaForwardPayoff, _p_VanillaForwardPayoffTo_p_StrikedTypePayoff, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StrippedOptionletAdapter[] = {  {&_swigt__p_StrippedOptionletAdapter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StrippedOptionletBase[] = {  {&_swigt__p_StrippedOptionletBase, 0, 0, 0},  {&_swigt__p_OptionletStripper1, _p_OptionletStripper1To_p_StrippedOptionletBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StudentDistribution[] = {  {&_swigt__p_StudentDistribution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StulzEngine[] = {  {&_swigt__p_StulzEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SuperSharePayoff[] = {  {&_swigt__p_SuperSharePayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SvenssonFitting[] = {  {&_swigt__p_SvenssonFitting, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Swap[] = {  {&_swigt__p_AssetSwap, _p_AssetSwapTo_p_Swap, 0, 0},  {&_swigt__p_OvernightIndexedSwap, _p_OvernightIndexedSwapTo_p_Swap, 0, 0},  {&_swigt__p_Swap, 0, 0, 0},  {&_swigt__p_VanillaSwap, _p_VanillaSwapTo_p_Swap, 0, 0},  {&_swigt__p_ZeroCouponInflationSwap, _p_ZeroCouponInflationSwapTo_p_Swap, 0, 0},  {&_swigt__p_YearOnYearInflationSwap, _p_YearOnYearInflationSwapTo_p_Swap, 0, 0},  {&_swigt__p_NonstandardSwap, _p_NonstandardSwapTo_p_Swap, 0, 0},  {&_swigt__p_CPISwap, _p_CPISwapTo_p_Swap, 0, 0},  {&_swigt__p_FloatFloatSwap, _p_FloatFloatSwapTo_p_Swap, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwapIndex[] = {  {&_swigt__p_EuriborSwapIsdaFixA, _p_EuriborSwapIsdaFixATo_p_SwapIndex, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixA, _p_EurLiborSwapIsdaFixATo_p_SwapIndex, 0, 0},  {&_swigt__p_EuriborSwapIsdaFixB, _p_EuriborSwapIsdaFixBTo_p_SwapIndex, 0, 0},  {&_swigt__p_EurLiborSwapIsdaFixB, _p_EurLiborSwapIsdaFixBTo_p_SwapIndex, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixAm, _p_JpyLiborSwapIsdaFixAmTo_p_SwapIndex, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixAm, _p_UsdLiborSwapIsdaFixAmTo_p_SwapIndex, 0, 0},  {&_swigt__p_OvernightIndexedSwapIndex, _p_OvernightIndexedSwapIndexTo_p_SwapIndex, 0, 0},  {&_swigt__p_SwapIndex, 0, 0, 0},  {&_swigt__p_EuriborSwapIfrFix, _p_EuriborSwapIfrFixTo_p_SwapIndex, 0, 0},  {&_swigt__p_EurLiborSwapIfrFix, _p_EurLiborSwapIfrFixTo_p_SwapIndex, 0, 0},  {&_swigt__p_JpyLiborSwapIsdaFixPm, _p_JpyLiborSwapIsdaFixPmTo_p_SwapIndex, 0, 0},  {&_swigt__p_UsdLiborSwapIsdaFixPm, _p_UsdLiborSwapIsdaFixPmTo_p_SwapIndex, 0, 0},  {&_swigt__p_ChfLiborSwapIsdaFix, _p_ChfLiborSwapIsdaFixTo_p_SwapIndex, 0, 0},  {&_swigt__p_GbpLiborSwapIsdaFix, _p_GbpLiborSwapIsdaFixTo_p_SwapIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwapRateHelper[] = {  {&_swigt__p_SwapRateHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwapSpreadIndex[] = {  {&_swigt__p_SwapSpreadIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Swaption[] = {  {&_swigt__p_Swaption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionHelper[] = {  {&_swigt__p_SwaptionHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionVolCube1[] = {  {&_swigt__p_SwaptionVolCube1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionVolCube2[] = {  {&_swigt__p_SwaptionVolCube2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionVolatilityCube[] = {  {&_swigt__p_SwaptionVolCube1, _p_SwaptionVolCube1To_p_SwaptionVolatilityCube, 0, 0},  {&_swigt__p_SwaptionVolatilityCube, 0, 0, 0},  {&_swigt__p_SwaptionVolCube2, _p_SwaptionVolCube2To_p_SwaptionVolatilityCube, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionVolatilityDiscrete[] = {  {&_swigt__p_SwaptionVolCube1, _p_SwaptionVolCube1To_p_SwaptionVolatilityDiscrete, 0, 0},  {&_swigt__p_SwaptionVolatilityCube, _p_SwaptionVolatilityCubeTo_p_SwaptionVolatilityDiscrete, 0, 0},  {&_swigt__p_SwaptionVolCube2, _p_SwaptionVolCube2To_p_SwaptionVolatilityDiscrete, 0, 0},  {&_swigt__p_SwaptionVolatilityMatrix, _p_SwaptionVolatilityMatrixTo_p_SwaptionVolatilityDiscrete, 0, 0},  {&_swigt__p_SwaptionVolatilityDiscrete, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionVolatilityMatrix[] = {  {&_swigt__p_SwaptionVolatilityMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwaptionVolatilityStructure[] = {  {&_swigt__p_SwaptionVolCube1, _p_SwaptionVolCube1To_p_SwaptionVolatilityStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityStructure, 0, 0, 0},  {&_swigt__p_SwaptionVolatilityCube, _p_SwaptionVolatilityCubeTo_p_SwaptionVolatilityStructure, 0, 0},  {&_swigt__p_SwaptionVolCube2, _p_SwaptionVolCube2To_p_SwaptionVolatilityStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityMatrix, _p_SwaptionVolatilityMatrixTo_p_SwaptionVolatilityStructure, 0, 0},  {&_swigt__p_ConstantSwaptionVolatility, _p_ConstantSwaptionVolatilityTo_p_SwaptionVolatilityStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityDiscrete, _p_SwaptionVolatilityDiscreteTo_p_SwaptionVolatilityStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SwingExercise[] = {  {&_swigt__p_SwingExercise, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_THBFIX[] = {  {&_swigt__p_THBFIX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TRLibor[] = {  {&_swigt__p_TRLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TemperatureExponential[] = {  {&_swigt__p_TemperatureExponential, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TermStructure[] = {  {&_swigt__p_SwaptionVolCube1, _p_SwaptionVolCube1To_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseLinearZero, _p_PiecewiseLinearZeroTo_p_TermStructure, 0, 0},  {&_swigt__p_SwaptionVolCube2, _p_SwaptionVolCube2To_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseCubicZero, _p_PiecewiseCubicZeroTo_p_TermStructure, 0, 0},  {&_swigt__p_ConstantOptionletVolatility, _p_ConstantOptionletVolatilityTo_p_TermStructure, 0, 0},  {&_swigt__p_ConstantSwaptionVolatility, _p_ConstantSwaptionVolatilityTo_p_TermStructure, 0, 0},  {&_swigt__p_ConstantYoYOptionletVolatility, _p_ConstantYoYOptionletVolatilityTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseLogLinearDiscount, _p_PiecewiseLogLinearDiscountTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseLogCubicDiscount, _p_PiecewiseLogCubicDiscountTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseSplineCubicDiscount, _p_PiecewiseSplineCubicDiscountTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseKrugerLogDiscount, _p_PiecewiseKrugerLogDiscountTo_p_TermStructure, 0, 0},  {&_swigt__p_YoYInflationCapFloorTermPriceSurface, _p_YoYInflationCapFloorTermPriceSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_CapFloorTermVolSurface, _p_CapFloorTermVolSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_YoYCapFloorTermPriceSurface, _p_YoYCapFloorTermPriceSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_YoYOptionletVolatilitySurface, _p_YoYOptionletVolatilitySurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_HestonBlackVolSurface, _p_HestonBlackVolSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_NoExceptLocalVolSurface, _p_NoExceptLocalVolSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_LocalVolSurface, _p_LocalVolSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_BlackVarianceSurface, _p_BlackVarianceSurfaceTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseZeroInflationCurveT_Linear_t, _p_PiecewiseZeroInflationCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseYoYInflationCurveT_Linear_t, _p_PiecewiseYoYInflationCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroInflationCurveT_Linear_t, _p_InterpolatedZeroInflationCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedYoYInflationCurveT_Linear_t, _p_InterpolatedYoYInflationCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedDefaultDensityCurveT_Linear_t, _p_InterpolatedDefaultDensityCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedSurvivalProbabilityCurveT_Linear_t, _p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_LogLinear_t, _p_InterpolatedDiscountCurveT_LogLinear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_Linear_t, _p_InterpolatedZeroCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_LogLinear_t, _p_InterpolatedZeroCurveT_LogLinear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t, _p_InterpolatedDiscountCurveT_MonotonicLogCubic_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_SplineCubic_t, _p_InterpolatedDiscountCurveT_SplineCubic_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_Cubic_t, _p_InterpolatedZeroCurveT_Cubic_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_MonotonicCubic_t, _p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_DefaultLogCubic_t, _p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_SplineCubic_t, _p_InterpolatedZeroCurveT_SplineCubic_tTo_p_TermStructure, 0, 0},  {&_swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t, _p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_BlackVarianceCurve, _p_BlackVarianceCurveTo_p_TermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityDiscrete, _p_SwaptionVolatilityDiscreteTo_p_TermStructure, 0, 0},  {&_swigt__p_FlatForward, _p_FlatForwardTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseFlatForward, _p_PiecewiseFlatForwardTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseLinearForward, _p_PiecewiseLinearForwardTo_p_TermStructure, 0, 0},  {&_swigt__p_StrippedOptionletAdapter, _p_StrippedOptionletAdapterTo_p_TermStructure, 0, 0},  {&_swigt__p_AndreasenHugeVolatilityAdapter, _p_AndreasenHugeVolatilityAdapterTo_p_TermStructure, 0, 0},  {&_swigt__p_AndreasenHugeLocalVolAdapter, _p_AndreasenHugeLocalVolAdapterTo_p_TermStructure, 0, 0},  {&_swigt__p_GlobalLinearSimpleZeroCurve, _p_GlobalLinearSimpleZeroCurveTo_p_TermStructure, 0, 0},  {&_swigt__p_ZeroInflationTermStructure, _p_ZeroInflationTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_YoYInflationTermStructure, _p_YoYInflationTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_InflationTermStructure, _p_InflationTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_YieldTermStructure, _p_YieldTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_ImpliedTermStructure, _p_ImpliedTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_ZeroSpreadedTermStructure, _p_ZeroSpreadedTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_ForwardSpreadedTermStructure, _p_ForwardSpreadedTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_VolatilityTermStructure, _p_VolatilityTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_BlackVolTermStructure, _p_BlackVolTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_LocalVolTermStructure, _p_LocalVolTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_OptionletVolatilityStructure, _p_OptionletVolatilityStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityStructure, _p_SwaptionVolatilityStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_DefaultProbabilityTermStructure, _p_DefaultProbabilityTermStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_CapFloorTermVolatilityStructure, _p_CapFloorTermVolatilityStructureTo_p_TermStructure, 0, 0},  {&_swigt__p_TermStructure, 0, 0, 0},  {&_swigt__p_PiecewiseKrugerZero, _p_PiecewiseKrugerZeroTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t, _p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t, _p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t, _p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_tTo_p_TermStructure, 0, 0},  {&_swigt__p_FittedBondDiscountCurve, _p_FittedBondDiscountCurveTo_p_TermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityCube, _p_SwaptionVolatilityCubeTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedForwardCurveT_BackwardFlat_t, _p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_TermStructure, 0, 0},  {&_swigt__p_InterpolatedHazardRateCurveT_BackwardFlat_t, _p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_TermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityMatrix, _p_SwaptionVolatilityMatrixTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseConvexMonotoneZero, _p_PiecewiseConvexMonotoneZeroTo_p_TermStructure, 0, 0},  {&_swigt__p_BlackConstantVol, _p_BlackConstantVolTo_p_TermStructure, 0, 0},  {&_swigt__p_LocalConstantVol, _p_LocalConstantVolTo_p_TermStructure, 0, 0},  {&_swigt__p_CapFloorTermVolCurve, _p_CapFloorTermVolCurveTo_p_TermStructure, 0, 0},  {&_swigt__p_PiecewiseFlatHazardRate, _p_PiecewiseFlatHazardRateTo_p_TermStructure, 0, 0},  {&_swigt__p_FlatHazardRate, _p_FlatHazardRateTo_p_TermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TermStructureConsistentModel[] = {  {&_swigt__p_TermStructureConsistentModel, 0, 0, 0},  {&_swigt__p_Gsr, _p_GsrTo_p_TermStructureConsistentModel, 0, 0},  {&_swigt__p_Gaussian1dModel, _p_Gaussian1dModelTo_p_TermStructureConsistentModel, 0, 0},  {&_swigt__p_MarkovFunctional, _p_MarkovFunctionalTo_p_TermStructureConsistentModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Tibor[] = {  {&_swigt__p_Tibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeBasket[] = {  {&_swigt__p_TimeBasket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeGrid[] = {  {&_swigt__p_TimeGrid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t[] = {  {&_swigt__p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t[] = {  {&_swigt__p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TrapezoidIntegralT_Default_t[] = {  {&_swigt__p_TrapezoidIntegralT_Default_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TrapezoidIntegralT_MidPoint_t[] = {  {&_swigt__p_TrapezoidIntegralT_MidPoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TreeCallableFixedRateBondEngine[] = {  {&_swigt__p_TreeCallableFixedRateBondEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TreeCapFloorEngine[] = {  {&_swigt__p_TreeCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TreeSwaptionEngine[] = {  {&_swigt__p_TreeSwaptionEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TridiagonalOperator[] = {  {&_swigt__p_DPlusDMinus, _p_DPlusDMinusTo_p_TridiagonalOperator, 0, 0},  {&_swigt__p_DMinus, _p_DMinusTo_p_TridiagonalOperator, 0, 0},  {&_swigt__p_DPlus, _p_DPlusTo_p_TridiagonalOperator, 0, 0},  {&_swigt__p_TridiagonalOperator, 0, 0, 0},  {&_swigt__p_DZero, _p_DZeroTo_p_TridiagonalOperator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TripleBandLinearOp[] = {  {&_swigt__p_TripleBandLinearOp, 0, 0, 0},  {&_swigt__p_FirstDerivativeOp, _p_FirstDerivativeOpTo_p_TripleBandLinearOp, 0, 0},  {&_swigt__p_SecondDerivativeOp, _p_SecondDerivativeOpTo_p_TripleBandLinearOp, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TypePayoff[] = {  {&_swigt__p_TypePayoff, 0, 0, 0},  {&_swigt__p_StrikedTypePayoff, _p_StrikedTypePayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_PlainVanillaPayoff, _p_PlainVanillaPayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_PercentageStrikePayoff, _p_PercentageStrikePayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_CashOrNothingPayoff, _p_CashOrNothingPayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_AssetOrNothingPayoff, _p_AssetOrNothingPayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_SuperSharePayoff, _p_SuperSharePayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_GapPayoff, _p_GapPayoffTo_p_TypePayoff, 0, 0},  {&_swigt__p_VanillaForwardPayoff, _p_VanillaForwardPayoffTo_p_TypePayoff, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UKRPI[] = {  {&_swigt__p_UKRPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_USCPI[] = {  {&_swigt__p_USCPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_USDLibor[] = {  {&_swigt__p_USDLibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_USDLiborON[] = {  {&_swigt__p_USDLiborON, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Uniform1dMesher[] = {  {&_swigt__p_Uniform1dMesher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UniformLowDiscrepancySequenceGenerator[] = {  {&_swigt__p_UniformLowDiscrepancySequenceGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UniformRandomGenerator[] = {  {&_swigt__p_UniformRandomGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UniformRandomSequenceGenerator[] = {  {&_swigt__p_UniformRandomSequenceGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UpRounding[] = {  {&_swigt__p_UpRounding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UpfrontCdsHelper[] = {  {&_swigt__p_UpfrontCdsHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UsdLiborSwapIsdaFixAm[] = {  {&_swigt__p_UsdLiborSwapIsdaFixAm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UsdLiborSwapIsdaFixPm[] = {  {&_swigt__p_UsdLiborSwapIsdaFixPm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VanillaForwardPayoff[] = {  {&_swigt__p_VanillaForwardPayoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VanillaOption[] = {  {&_swigt__p_EuropeanOption, _p_EuropeanOptionTo_p_VanillaOption, 0, 0},  {&_swigt__p_VanillaOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VanillaSwap[] = {  {&_swigt__p_VanillaSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VanillaSwingOption[] = {  {&_swigt__p_VanillaSwingOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VannaVolgaBarrierEngine[] = {  {&_swigt__p_VannaVolgaBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t[] = {  {&_swigt__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t[] = {  {&_swigt__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VarianceGammaEngine[] = {  {&_swigt__p_VarianceGammaEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VarianceGammaProcess[] = {  {&_swigt__p_VarianceGammaProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Vasicek[] = {  {&_swigt__p_Vasicek, 0, 0, 0},  {&_swigt__p_HullWhite, _p_HullWhiteTo_p_Vasicek, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VolatilityTermStructure[] = {  {&_swigt__p_AndreasenHugeVolatilityAdapter, _p_AndreasenHugeVolatilityAdapterTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_AndreasenHugeLocalVolAdapter, _p_AndreasenHugeLocalVolAdapterTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_StrippedOptionletAdapter, _p_StrippedOptionletAdapterTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t, _p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_CapFloorTermVolCurve, _p_CapFloorTermVolCurveTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_LocalConstantVol, _p_LocalConstantVolTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_BlackConstantVol, _p_BlackConstantVolTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_BlackVarianceCurve, _p_BlackVarianceCurveTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_SwaptionVolCube1, _p_SwaptionVolCube1To_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_ConstantSwaptionVolatility, _p_ConstantSwaptionVolatilityTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_ConstantOptionletVolatility, _p_ConstantOptionletVolatilityTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_ConstantYoYOptionletVolatility, _p_ConstantYoYOptionletVolatilityTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityMatrix, _p_SwaptionVolatilityMatrixTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_SwaptionVolCube2, _p_SwaptionVolCube2To_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityCube, _p_SwaptionVolatilityCubeTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityDiscrete, _p_SwaptionVolatilityDiscreteTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_VolatilityTermStructure, 0, 0, 0},  {&_swigt__p_NoExceptLocalVolSurface, _p_NoExceptLocalVolSurfaceTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_LocalVolSurface, _p_LocalVolSurfaceTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_BlackVarianceSurface, _p_BlackVarianceSurfaceTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_YoYOptionletVolatilitySurface, _p_YoYOptionletVolatilitySurfaceTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_SwaptionVolatilityStructure, _p_SwaptionVolatilityStructureTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_OptionletVolatilityStructure, _p_OptionletVolatilityStructureTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_LocalVolTermStructure, _p_LocalVolTermStructureTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_BlackVolTermStructure, _p_BlackVolTermStructureTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_HestonBlackVolSurface, _p_HestonBlackVolSurfaceTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_CapFloorTermVolatilityStructure, _p_CapFloorTermVolatilityStructureTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_CapFloorTermVolSurface, _p_CapFloorTermVolSurfaceTo_p_VolatilityTermStructure, 0, 0},  {&_swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t, _p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_VolatilityTermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Wibor[] = {  {&_swigt__p_Wibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WulinYongDoubleBarrierEngine[] = {  {&_swigt__p_WulinYongDoubleBarrierEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYEUHICP[] = {  {&_swigt__p_YYEUHICP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYEUHICPXT[] = {  {&_swigt__p_YYEUHICPXT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYEUHICPr[] = {  {&_swigt__p_YYEUHICPr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYFRHICP[] = {  {&_swigt__p_YYFRHICP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYFRHICPr[] = {  {&_swigt__p_YYFRHICPr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYUKRPI[] = {  {&_swigt__p_YYUKRPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYUKRPIr[] = {  {&_swigt__p_YYUKRPIr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYUSCPI[] = {  {&_swigt__p_YYUSCPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYUSCPIr[] = {  {&_swigt__p_YYUSCPIr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYZACPI[] = {  {&_swigt__p_YYZACPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YYZACPIr[] = {  {&_swigt__p_YYZACPIr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YearOnYearInflationSwap[] = {  {&_swigt__p_YearOnYearInflationSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YearOnYearInflationSwapHelper[] = {  {&_swigt__p_YearOnYearInflationSwapHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YieldTermStructure[] = {  {&_swigt__p_FittedBondDiscountCurve, _p_FittedBondDiscountCurveTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseLinearForward, _p_PiecewiseLinearForwardTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseFlatForward, _p_PiecewiseFlatForwardTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_FlatForward, _p_FlatForwardTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseConvexMonotoneZero, _p_PiecewiseConvexMonotoneZeroTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_MonotonicCubic_t, _p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t, _p_InterpolatedDiscountCurveT_MonotonicLogCubic_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_SplineCubic_t, _p_InterpolatedDiscountCurveT_SplineCubic_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_Cubic_t, _p_InterpolatedZeroCurveT_Cubic_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_SplineCubic_t, _p_InterpolatedZeroCurveT_SplineCubic_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_DefaultLogCubic_t, _p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t, _p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t, _p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_GlobalLinearSimpleZeroCurve, _p_GlobalLinearSimpleZeroCurveTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseKrugerZero, _p_PiecewiseKrugerZeroTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseCubicZero, _p_PiecewiseCubicZeroTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedDiscountCurveT_LogLinear_t, _p_InterpolatedDiscountCurveT_LogLinear_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_Linear_t, _p_InterpolatedZeroCurveT_Linear_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroCurveT_LogLinear_t, _p_InterpolatedZeroCurveT_LogLinear_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseSplineCubicDiscount, _p_PiecewiseSplineCubicDiscountTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseLogCubicDiscount, _p_PiecewiseLogCubicDiscountTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseLogLinearDiscount, _p_PiecewiseLogLinearDiscountTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseKrugerLogDiscount, _p_PiecewiseKrugerLogDiscountTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_InterpolatedForwardCurveT_BackwardFlat_t, _p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_YieldTermStructure, 0, 0, 0},  {&_swigt__p_ForwardSpreadedTermStructure, _p_ForwardSpreadedTermStructureTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_ZeroSpreadedTermStructure, _p_ZeroSpreadedTermStructureTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_ImpliedTermStructure, _p_ImpliedTermStructureTo_p_YieldTermStructure, 0, 0},  {&_swigt__p_PiecewiseLinearZero, _p_PiecewiseLinearZeroTo_p_YieldTermStructure, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYCapFloorTermPriceSurface[] = {  {&_swigt__p_YoYCapFloorTermPriceSurface, 0, 0, 0},  {&_swigt__p_YoYInflationCapFloorTermPriceSurface, _p_YoYInflationCapFloorTermPriceSurfaceTo_p_YoYCapFloorTermPriceSurface, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationBachelierCapFloorEngine[] = {  {&_swigt__p_YoYInflationBachelierCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationBlackCapFloorEngine[] = {  {&_swigt__p_YoYInflationBlackCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationCap[] = {  {&_swigt__p_YoYInflationCap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationCapFloor[] = {  {&_swigt__p_YoYInflationCollar, _p_YoYInflationCollarTo_p_YoYInflationCapFloor, 0, 0},  {&_swigt__p_YoYInflationCapFloor, 0, 0, 0},  {&_swigt__p_YoYInflationCap, _p_YoYInflationCapTo_p_YoYInflationCapFloor, 0, 0},  {&_swigt__p_YoYInflationFloor, _p_YoYInflationFloorTo_p_YoYInflationCapFloor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationCapFloorTermPriceSurface[] = {  {&_swigt__p_YoYInflationCapFloorTermPriceSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationCollar[] = {  {&_swigt__p_YoYInflationCollar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationFloor[] = {  {&_swigt__p_YoYInflationFloor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationIndex[] = {  {&_swigt__p_YYEUHICP, _p_YYEUHICPTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYUSCPI, _p_YYUSCPITo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYUSCPIr, _p_YYUSCPIrTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYUKRPI, _p_YYUKRPITo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYZACPIr, _p_YYZACPIrTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYZACPI, _p_YYZACPITo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYFRHICP, _p_YYFRHICPTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYUKRPIr, _p_YYUKRPIrTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YoYInflationIndex, 0, 0, 0},  {&_swigt__p_YYEUHICPXT, _p_YYEUHICPXTTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYEUHICPr, _p_YYEUHICPrTo_p_YoYInflationIndex, 0, 0},  {&_swigt__p_YYFRHICPr, _p_YYFRHICPrTo_p_YoYInflationIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationTermStructure[] = {  {&_swigt__p_PiecewiseYoYInflationCurveT_Linear_t, _p_PiecewiseYoYInflationCurveT_Linear_tTo_p_YoYInflationTermStructure, 0, 0},  {&_swigt__p_InterpolatedYoYInflationCurveT_Linear_t, _p_InterpolatedYoYInflationCurveT_Linear_tTo_p_YoYInflationTermStructure, 0, 0},  {&_swigt__p_YoYInflationTermStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYInflationUnitDisplacedBlackCapFloorEngine[] = {  {&_swigt__p_YoYInflationUnitDisplacedBlackCapFloorEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYOptionletHelper[] = {  {&_swigt__p_YoYOptionletHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYOptionletStripper[] = {  {&_swigt__p_InterpolatedYoYOptionletStripperT_Linear_t, _p_InterpolatedYoYOptionletStripperT_Linear_tTo_p_YoYOptionletStripper, 0, 0},  {&_swigt__p_YoYOptionletStripper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_YoYOptionletVolatilitySurface[] = {  {&_swigt__p_YoYOptionletVolatilitySurface, 0, 0, 0},  {&_swigt__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t, _p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_YoYOptionletVolatilitySurface, 0, 0},  {&_swigt__p_ConstantYoYOptionletVolatility, _p_ConstantYoYOptionletVolatilityTo_p_YoYOptionletVolatilitySurface, 0, 0},  {&_swigt__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t, _p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_YoYOptionletVolatilitySurface, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZACPI[] = {  {&_swigt__p_ZACPI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrFullFd[] = {  {&_swigt__p_ZabrFullFd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t[] = {  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t[] = {  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t[] = {  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t[] = {  {&_swigt__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrLocalVolatility[] = {  {&_swigt__p_ZabrLocalVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrShortMaturityLognormal[] = {  {&_swigt__p_ZabrShortMaturityLognormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrShortMaturityNormal[] = {  {&_swigt__p_ZabrShortMaturityNormal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrSmileSectionT_ZabrFullFd_t[] = {  {&_swigt__p_ZabrSmileSectionT_ZabrFullFd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrSmileSectionT_ZabrLocalVolatility_t[] = {  {&_swigt__p_ZabrSmileSectionT_ZabrLocalVolatility_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t[] = {  {&_swigt__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t[] = {  {&_swigt__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroCouponBond[] = {  {&_swigt__p_ZeroCouponBond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroCouponInflationSwap[] = {  {&_swigt__p_ZeroCouponInflationSwap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroCouponInflationSwapHelper[] = {  {&_swigt__p_ZeroCouponInflationSwapHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroInflationIndex[] = {  {&_swigt__p_EUHICP, _p_EUHICPTo_p_ZeroInflationIndex, 0, 0},  {&_swigt__p_AUCPI, _p_AUCPITo_p_ZeroInflationIndex, 0, 0},  {&_swigt__p_FRHICP, _p_FRHICPTo_p_ZeroInflationIndex, 0, 0},  {&_swigt__p_USCPI, _p_USCPITo_p_ZeroInflationIndex, 0, 0},  {&_swigt__p_UKRPI, _p_UKRPITo_p_ZeroInflationIndex, 0, 0},  {&_swigt__p_ZeroInflationIndex, 0, 0, 0},  {&_swigt__p_ZACPI, _p_ZACPITo_p_ZeroInflationIndex, 0, 0},  {&_swigt__p_EUHICPXT, _p_EUHICPXTTo_p_ZeroInflationIndex, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroInflationTermStructure[] = {  {&_swigt__p_PiecewiseZeroInflationCurveT_Linear_t, _p_PiecewiseZeroInflationCurveT_Linear_tTo_p_ZeroInflationTermStructure, 0, 0},  {&_swigt__p_InterpolatedZeroInflationCurveT_Linear_t, _p_InterpolatedZeroInflationCurveT_Linear_tTo_p_ZeroInflationTermStructure, 0, 0},  {&_swigt__p_ZeroInflationTermStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroSpreadedTermStructure[] = {  {&_swigt__p_ZeroSpreadedTermStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ZeroYield[] = {  {&_swigt__p_ZeroYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Zibor[] = {  {&_swigt__p_Zibor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__GlobalBootstrap[] = {  {&_swigt__p__GlobalBootstrap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__IterativeBootstrap[] = {  {&_swigt__p__IterativeBootstrap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__functionT_double_fdoubleF_t[] = {  {&_swigt__p_ext__functionT_double_fdoubleF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AUCPI_t[] = {  {&_swigt__p_ext__shared_ptrT_AUCPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AUDLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_AUDLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AmericanExercise_t[] = {  {&_swigt__p_ext__shared_ptrT_AmericanExercise_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AmortizingFixedRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_AmortizingFixedRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AmortizingFloatingRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_AmortizingFloatingRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AmortizingPayment_t[] = {  {&_swigt__p_ext__shared_ptrT_AmortizingPayment_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticCEVEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticCEVEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticEuropeanEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticEuropeanEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticHaganPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticHaganPricer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticHestonEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticHestonEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t[] = {  {&_swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t[] = {  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t[] = {  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Aonia_t[] = {  {&_swigt__p_ext__shared_ptrT_Aonia_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AssetOrNothingPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_AssetOrNothingPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AssetSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_AssetSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_AverageBasketPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_AverageBasketPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BFGS_t[] = {  {&_swigt__p_ext__shared_ptrT_BFGS_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BSMRNDCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_BSMRNDCalculator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BachelierCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BachelierCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BachelierSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BachelierSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BarrierOption_t[] = {  {&_swigt__p_ext__shared_ptrT_BarrierOption_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendBarrierOption_t, _p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_BarrierOption_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BasketOption_t[] = {  {&_swigt__p_ext__shared_ptrT_BasketOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BasketPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_BasketPayoff_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_MinBasketPayoff_t, _p_ext__shared_ptrT_MinBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MaxBasketPayoff_t, _p_ext__shared_ptrT_MaxBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AverageBasketPayoff_t, _p_ext__shared_ptrT_AverageBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadBasketPayoff_t, _p_ext__shared_ptrT_SpreadBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BatesEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BatesEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BatesModel_t[] = {  {&_swigt__p_ext__shared_ptrT_BatesModel_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BatesProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_BatesProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw1M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw1M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw2M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw2M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw3M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw3M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw4M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw4M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw5M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw5M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw6M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw6M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bbsw_t[] = {  {&_swigt__p_ext__shared_ptrT_Bbsw_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw5M_t, _p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_Bbsw_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw6M_t, _p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_Bbsw_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw1M_t, _p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_Bbsw_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw2M_t, _p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_Bbsw_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw3M_t, _p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_Bbsw_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw4M_t, _p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_Bbsw_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BermudanExercise_t[] = {  {&_swigt__p_ext__shared_ptrT_BermudanExercise_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BiCGstab_t[] = {  {&_swigt__p_ext__shared_ptrT_BiCGstab_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor1M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor1M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor1Y_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor1Y_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor2M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor2M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor3M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor3M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor6M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor6M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor9M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor9M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BiborSW_t[] = {  {&_swigt__p_ext__shared_ptrT_BiborSW_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bibor_t[] = {  {&_swigt__p_ext__shared_ptrT_Bibor_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BiborSW_t, _p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor6M_t, _p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1M_t, _p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor2M_t, _p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor9M_t, _p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor3M_t, _p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1Y_t, _p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_Bibor_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm1M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm1M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm2M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm2M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm3M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm3M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm4M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm4M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm5M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm5M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm6M_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm6M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bkbm_t[] = {  {&_swigt__p_ext__shared_ptrT_Bkbm3M_t, _p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_Bkbm_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm4M_t, _p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_Bkbm_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm5M_t, _p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_Bkbm_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm6M_t, _p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_Bkbm_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm1M_t, _p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_Bkbm_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm2M_t, _p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_Bkbm_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackCalibrationHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackCalibrationHelper_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionHelper_t, _p_ext__shared_ptrT_SwaptionHelper_tTo_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapHelper_t, _p_ext__shared_ptrT_CapHelper_tTo_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonModelHelper_t, _p_ext__shared_ptrT_HestonModelHelper_tTo_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackCdsOptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackCdsOptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackConstantVol_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackConstantVol_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackIborCouponPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackIborCouponPricer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackKarasinski_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackKarasinski_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackScholesMertonProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackScholesProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackScholesProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackVarianceCurve_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackVarianceCurve_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackVarianceSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackVarianceSurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BlackVolTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackVarianceSurface_t, _p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t, _p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVolTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackConstantVol_t, _p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceCurve_t, _p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, _p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BondHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_BondHelper_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBondHelper_t, _p_ext__shared_ptrT_FixedRateBondHelper_tTo_p_ext__shared_ptrT_BondHelper_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Bond_t[] = {  {&_swigt__p_ext__shared_ptrT_ZeroCouponBond_t, _p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t, _p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, _p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, _p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBond_t, _p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingFixedRateBond_t, _p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingFloatingRateBond_t, _p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatingRateBond_t, _p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsRateBond_t, _p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableBond_t, _p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableFixedRateBond_t, _p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPIBond_t, _p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, _p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_Bond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t, _p_ext__shared_ptrT_YearOnYearInflationSwapHelper_tTo_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletHelper_t, _p_ext__shared_ptrT_YoYOptionletHelper_tTo_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t[] = {  {&_swigt__p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t, _p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_tTo_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BoundaryConstraint_t[] = {  {&_swigt__p_ext__shared_ptrT_BoundaryConstraint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_BrownianGeneratorFactory_t[] = {  {&_swigt__p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, _p_ext__shared_ptrT_SobolBrownianGeneratorFactory_tTo_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_MTBrownianGeneratorFactory_t, _p_ext__shared_ptrT_MTBrownianGeneratorFactory_tTo_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CADLiborON_t[] = {  {&_swigt__p_ext__shared_ptrT_CADLiborON_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CADLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_CADLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CEVRNDCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_CEVRNDCalculator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CHFLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_CHFLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_COSHestonEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_COSHestonEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CPIBond_t[] = {  {&_swigt__p_ext__shared_ptrT_CPIBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CPICoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CPICoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CPISwap_t[] = {  {&_swigt__p_ext__shared_ptrT_CPISwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CalibratedModel_t[] = {  {&_swigt__p_ext__shared_ptrT_Vasicek_t, _p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2_t, _p_ext__shared_ptrT_G2_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CalibratedModel_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhite_t, _p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonModel_t, _p_ext__shared_ptrT_HestonModel_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesModel_t, _p_ext__shared_ptrT_BatesModel_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GJRGARCHModel_t, _p_ext__shared_ptrT_GJRGARCHModel_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ShortRateModel_t, _p_ext__shared_ptrT_ShortRateModel_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneFactorAffineModel_t, _p_ext__shared_ptrT_OneFactorAffineModel_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CoxIngersollRoss_t, _p_ext__shared_ptrT_CoxIngersollRoss_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, _p_ext__shared_ptrT_ExtendedCoxIngersollRoss_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackKarasinski_t, _p_ext__shared_ptrT_BlackKarasinski_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, _p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_tTo_p_ext__shared_ptrT_CalibratedModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CalibrationHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_CalibrationHelper_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCalibrationHelper_t, _p_ext__shared_ptrT_BlackCalibrationHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionHelper_t, _p_ext__shared_ptrT_SwaptionHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapHelper_t, _p_ext__shared_ptrT_CapHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonModelHelper_t, _p_ext__shared_ptrT_HestonModelHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Callability_t[] = {  {&_swigt__p_ext__shared_ptrT_Callability_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SoftCallability_t, _p_ext__shared_ptrT_SoftCallability_tTo_p_ext__shared_ptrT_Callability_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CallableBond_t[] = {  {&_swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t, _p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_CallableBond_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableBond_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableFixedRateBond_t, _p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_CallableBond_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CallableFixedRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_CallableFixedRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CallableZeroCouponBond_t[] = {  {&_swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CapFloorTermVolCurve_t[] = {  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CapFloorTermVolSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t, _p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t, _p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CapFloor_t[] = {  {&_swigt__p_ext__shared_ptrT_CapFloor_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Floor_t, _p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_CapFloor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Collar_t, _p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_CapFloor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cap_t, _p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_CapFloor_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CapHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_CapHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Cap_t[] = {  {&_swigt__p_ext__shared_ptrT_Cap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CappedFlooredCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t, _p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CappedFlooredIborCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CashFlow_t[] = {  {&_swigt__p_ext__shared_ptrT_CPICoupon_t, _p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationCoupon_t, _p_ext__shared_ptrT_InflationCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t, _p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsCoupon_t, _p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborCoupon_t, _p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t, _p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t, _p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t, _p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatingRateCoupon_t, _p_ext__shared_ptrT_FloatingRateCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateCoupon_t, _p_ext__shared_ptrT_FixedRateCoupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Coupon_t, _p_ext__shared_ptrT_Coupon_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Redemption_t, _p_ext__shared_ptrT_Redemption_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CashFlow_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_IndexedCashFlow_t, _p_ext__shared_ptrT_IndexedCashFlow_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingPayment_t, _p_ext__shared_ptrT_AmortizingPayment_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SimpleCashFlow_t, _p_ext__shared_ptrT_SimpleCashFlow_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FractionalDividend_t, _p_ext__shared_ptrT_FractionalDividend_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedDividend_t, _p_ext__shared_ptrT_FixedDividend_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Dividend_t, _p_ext__shared_ptrT_Dividend_tTo_p_ext__shared_ptrT_CashFlow_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CashOrNothingPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_CashOrNothingPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Cdor_t[] = {  {&_swigt__p_ext__shared_ptrT_Cdor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CdsOption_t[] = {  {&_swigt__p_ext__shared_ptrT_CdsOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t[] = {  {&_swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Claim_t[] = {  {&_swigt__p_ext__shared_ptrT_Claim_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FaceValueClaim_t, _p_ext__shared_ptrT_FaceValueClaim_tTo_p_ext__shared_ptrT_Claim_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FaceValueAccrualClaim_t, _p_ext__shared_ptrT_FaceValueAccrualClaim_tTo_p_ext__shared_ptrT_Claim_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CmsCouponPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_CmsCouponPricer_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticHaganPricer_t, _p_ext__shared_ptrT_AnalyticHaganPricer_tTo_p_ext__shared_ptrT_CmsCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NumericHaganPricer_t, _p_ext__shared_ptrT_NumericHaganPricer_tTo_p_ext__shared_ptrT_CmsCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LinearTsrPricer_t, _p_ext__shared_ptrT_LinearTsrPricer_tTo_p_ext__shared_ptrT_CmsCouponPricer_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CmsCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CmsCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CmsMarket_t[] = {  {&_swigt__p_ext__shared_ptrT_CmsMarket_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CmsRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_CmsRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CmsSpreadCouponPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, _p_ext__shared_ptrT_LognormalCmsSpreadPricer_tTo_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CmsSpreadCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Collar_t[] = {  {&_swigt__p_ext__shared_ptrT_Collar_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CompositeConstraint_t[] = {  {&_swigt__p_ext__shared_ptrT_CompositeConstraint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CompositeInstrument_t[] = {  {&_swigt__p_ext__shared_ptrT_CompositeInstrument_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t[] = {  {&_swigt__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Concentrating1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_Concentrating1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConjugateGradient_t[] = {  {&_swigt__p_ext__shared_ptrT_ConjugateGradient_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConstantOptionletVolatility_t[] = {  {&_swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConstantSwaptionVolatility_t[] = {  {&_swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t[] = {  {&_swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Constraint_t[] = {  {&_swigt__p_ext__shared_ptrT_Constraint_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BoundaryConstraint_t, _p_ext__shared_ptrT_BoundaryConstraint_tTo_p_ext__shared_ptrT_Constraint_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoConstraint_t, _p_ext__shared_ptrT_NoConstraint_tTo_p_ext__shared_ptrT_Constraint_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PositiveConstraint_t, _p_ext__shared_ptrT_PositiveConstraint_tTo_p_ext__shared_ptrT_Constraint_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CompositeConstraint_t, _p_ext__shared_ptrT_CompositeConstraint_tTo_p_ext__shared_ptrT_Constraint_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t, _p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_tTo_p_ext__shared_ptrT_Constraint_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t[] = {  {&_swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t[] = {  {&_swigt__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t[] = {  {&_swigt__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Coupon_t[] = {  {&_swigt__p_ext__shared_ptrT_Coupon_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateCoupon_t, _p_ext__shared_ptrT_FixedRateCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatingRateCoupon_t, _p_ext__shared_ptrT_FloatingRateCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t, _p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t, _p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t, _p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborCoupon_t, _p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsCoupon_t, _p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t, _p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationCoupon_t, _p_ext__shared_ptrT_InflationCoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPICoupon_t, _p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_Coupon_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CoxIngersollRoss_t[] = {  {&_swigt__p_ext__shared_ptrT_CoxIngersollRoss_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CraigSneydScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_CraigSneydScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CrankNicolsonScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_CrankNicolsonScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_CreditDefaultSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_CreditDefaultSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DKKLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_DKKLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DailyTenorLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_DailyTenorLibor_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLiborON_t, _p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_DailyTenorLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLiborON_t, _p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_DailyTenorLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLiborON_t, _p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_DailyTenorLibor_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DatedOISRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_DatedOISRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DefaultBoundaryCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_NeumannBC_t, _p_ext__shared_ptrT_NeumannBC_tTo_p_ext__shared_ptrT_DefaultBoundaryCondition_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DirichletBC_t, _p_ext__shared_ptrT_DirichletBC_tTo_p_ext__shared_ptrT_DefaultBoundaryCondition_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DefaultBoundaryCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DefaultProbabilityHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadCdsHelper_t, _p_ext__shared_ptrT_SpreadCdsHelper_tTo_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UpfrontCdsHelper_t, _p_ext__shared_ptrT_UpfrontCdsHelper_tTo_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatHazardRate_t, _p_ext__shared_ptrT_FlatHazardRate_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, _p_ext__shared_ptrT_PiecewiseFlatHazardRate_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DeltaVolQuote_t[] = {  {&_swigt__p_ext__shared_ptrT_DeltaVolQuote_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DepositRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_DepositRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t[] = {  {&_swigt__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DifferentialEvolution_t[] = {  {&_swigt__p_ext__shared_ptrT_DifferentialEvolution_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DirichletBC_t[] = {  {&_swigt__p_ext__shared_ptrT_DirichletBC_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DiscountingBondEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_DiscountingBondEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DiscountingSwapEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_DiscountingSwapEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t[] = {  {&_swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DividendBarrierOption_t[] = {  {&_swigt__p_ext__shared_ptrT_DividendBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DividendVanillaOption_t[] = {  {&_swigt__p_ext__shared_ptrT_DividendVanillaOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Dividend_t[] = {  {&_swigt__p_ext__shared_ptrT_Dividend_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedDividend_t, _p_ext__shared_ptrT_FixedDividend_tTo_p_ext__shared_ptrT_Dividend_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FractionalDividend_t, _p_ext__shared_ptrT_FractionalDividend_tTo_p_ext__shared_ptrT_Dividend_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DoubleBarrierOption_t[] = {  {&_swigt__p_ext__shared_ptrT_DoubleBarrierOption_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, _p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_DoubleBarrierOption_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_DouglasScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_DouglasScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EUHICPXT_t[] = {  {&_swigt__p_ext__shared_ptrT_EUHICPXT_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EUHICP_t[] = {  {&_swigt__p_ext__shared_ptrT_EUHICP_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor10M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor10M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor11M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor11M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor1M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor1M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor1Y_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor1Y_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor2M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor2M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor2W_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor2W_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor3M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor3M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor4M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor4M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor5M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor5M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor6M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor6M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor7M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor7M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor8M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor8M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor9M_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor9M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLiborSW_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLiborSW_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EURLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_EURLibor2M_t, _p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor4M_t, _p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor6M_t, _p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor8M_t, _p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1Y_t, _p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor10M_t, _p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2W_t, _p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1M_t, _p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor3M_t, _p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor5M_t, _p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor7M_t, _p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor9M_t, _p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLiborSW_t, _p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor11M_t, _p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_EURLibor_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EndCriteria_t[] = {  {&_swigt__p_ext__shared_ptrT_EndCriteria_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Eonia_t[] = {  {&_swigt__p_ext__shared_ptrT_Eonia_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EurLiborSwapIfrFix_t[] = {  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t[] = {  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t[] = {  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor10M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor10M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor11M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor11M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor1M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor1M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor1Y_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor1Y_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor2M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor2M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor2W_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor2W_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_10M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_10M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_11M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_11M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_1M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_1M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_1Y_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_1Y_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_2M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_2M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_2W_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_2W_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_3M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_3M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_3W_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_3W_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_4M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_4M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_5M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_5M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_6M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_6M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_7M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_7M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_8M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_8M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_9M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_9M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_SW_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_SW_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor365_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor365_6M_t, _p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_8M_t, _p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1Y_t, _p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_10M_t, _p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2W_t, _p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1M_t, _p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3M_t, _p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_5M_t, _p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_7M_t, _p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_9M_t, _p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_11M_t, _p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_SW_t, _p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3W_t, _p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2M_t, _p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_4M_t, _p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_Euribor365_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor3M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor3M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor3W_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor3W_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor4M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor4M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor5M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor5M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor6M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor6M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor7M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor7M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor8M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor8M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor9M_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor9M_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EuriborSW_t[] = {  {&_swigt__p_ext__shared_ptrT_EuriborSW_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EuriborSwapIfrFix_t[] = {  {&_swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t[] = {  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t[] = {  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Euribor_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor2M_t, _p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor4M_t, _p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor6M_t, _p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor8M_t, _p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1Y_t, _p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor10M_t, _p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2W_t, _p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1M_t, _p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3M_t, _p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor5M_t, _p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor7M_t, _p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor9M_t, _p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSW_t, _p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3W_t, _p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor11M_t, _p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_Euribor_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EuropeanExercise_t[] = {  {&_swigt__p_ext__shared_ptrT_EuropeanExercise_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EuropeanOption_t[] = {  {&_swigt__p_ext__shared_ptrT_EuropeanOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_EverestOption_t[] = {  {&_swigt__p_ext__shared_ptrT_EverestOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Exercise_t[] = {  {&_swigt__p_ext__shared_ptrT_Exercise_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuropeanExercise_t, _p_ext__shared_ptrT_EuropeanExercise_tTo_p_ext__shared_ptrT_Exercise_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmericanExercise_t, _p_ext__shared_ptrT_AmericanExercise_tTo_p_ext__shared_ptrT_Exercise_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BermudanExercise_t, _p_ext__shared_ptrT_BermudanExercise_tTo_p_ext__shared_ptrT_Exercise_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_RebatedExercise_t, _p_ext__shared_ptrT_RebatedExercise_tTo_p_ext__shared_ptrT_Exercise_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwingExercise_t, _p_ext__shared_ptrT_SwingExercise_tTo_p_ext__shared_ptrT_Exercise_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ExplicitEulerScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_ExplicitEulerScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ExponentialJump1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_ExponentialJump1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t[] = {  {&_swigt__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FFTVarianceGammaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FFTVarianceGammaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FRHICP_t[] = {  {&_swigt__p_ext__shared_ptrT_FRHICP_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FaceValueAccrualClaim_t[] = {  {&_swigt__p_ext__shared_ptrT_FaceValueAccrualClaim_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FaceValueClaim_t[] = {  {&_swigt__p_ext__shared_ptrT_FaceValueClaim_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdBatesVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdBatesVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdCEVVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdCEVVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdG2SwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdG2SwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdHestonBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdHestonBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdHestonRebateEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdHestonRebateEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdHestonVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdHestonVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdSabrVanillaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdSabrVanillaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fdm1DimSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_Fdm1DimSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fdm1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, _p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesMesher_t, _p_ext__shared_ptrT_FdmBlackScholesMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Concentrating1dMesher_t, _p_ext__shared_ptrT_Concentrating1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExponentialJump1dMesher_t, _p_ext__shared_ptrT_ExponentialJump1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmCEV1dMesher_t, _p_ext__shared_ptrT_FdmCEV1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonVarianceMesher_t, _p_ext__shared_ptrT_FdmHestonVarianceMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, _p_ext__shared_ptrT_FdmSimpleProcess1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Uniform1dMesher_t, _p_ext__shared_ptrT_Uniform1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Predefined1dMesher_t, _p_ext__shared_ptrT_Predefined1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Glued1dMesher_t, _p_ext__shared_ptrT_Glued1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fdm2DimSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_Fdm2DimSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t[] = {  {&_swigt__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Fdm3DimSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_Fdm3DimSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmAmericanStepCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmAmericanStepCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmArithmeticAverageCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmArithmeticAverageCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBackwardSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmBackwardSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBatesOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmBatesOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBermudanStepCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmBermudanStepCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBlackScholesMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBlackScholesOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmBoundaryCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmDirichletBoundary_t, _p_ext__shared_ptrT_FdmDirichletBoundary_tTo_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t, _p_ext__shared_ptrT_FdmDiscountDirichletBoundary_tTo_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t, _p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_tTo_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBoundaryCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmCEV1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmCEV1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmCEVOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmCEVOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmCellAveragingInnerValue_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLogInnerValue_t, _p_ext__shared_ptrT_FdmLogInnerValue_tTo_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmDirichletBoundary_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmDirichletBoundary_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmDividendHandler_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmDividendHandler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmDupire1dOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmDupire1dOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmG2Op_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmG2Op_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmG2Solver_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmG2Solver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonFwdOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonFwdOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHestonVarianceMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHestonVarianceMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHullWhiteOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHullWhiteOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmHullWhiteSolver_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmHullWhiteSolver_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmIndicesOnBoundary_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmIndicesOnBoundary_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmInnerValueCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t, _p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t, _p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t, _p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, _p_ext__shared_ptrT_FdmCellAveragingInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLogInnerValue_t, _p_ext__shared_ptrT_FdmLogInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLogBasketInnerValue_t, _p_ext__shared_ptrT_FdmLogBasketInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmZeroInnerValue_t, _p_ext__shared_ptrT_FdmZeroInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLinearOpComposite_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t, _p_ext__shared_ptrT_FdmLinearOpCompositeProxy_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmCEVOp_t, _p_ext__shared_ptrT_FdmCEVOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHullWhiteOp_t, _p_ext__shared_ptrT_FdmHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t, _p_ext__shared_ptrT_FdmHestonHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmZabrOp_t, _p_ext__shared_ptrT_FdmZabrOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSabrOp_t, _p_ext__shared_ptrT_FdmSabrOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, _p_ext__shared_ptrT_Fdm2dBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesOp_t, _p_ext__shared_ptrT_FdmBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBatesOp_t, _p_ext__shared_ptrT_FdmBatesOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonFwdOp_t, _p_ext__shared_ptrT_FdmHestonFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSquareRootFwdOp_t, _p_ext__shared_ptrT_FdmSquareRootFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, _p_ext__shared_ptrT_FdmBlackScholesFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLocalVolFwdOp_t, _p_ext__shared_ptrT_FdmLocalVolFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmG2Op_t, _p_ext__shared_ptrT_FdmG2Op_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonOp_t, _p_ext__shared_ptrT_FdmHestonOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, _p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmDupire1dOp_t, _p_ext__shared_ptrT_FdmDupire1dOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLinearOpLayout_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLinearOpLayout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLinearOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t, _p_ext__shared_ptrT_FdmLinearOpCompositeProxy_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmCEVOp_t, _p_ext__shared_ptrT_FdmCEVOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHullWhiteOp_t, _p_ext__shared_ptrT_FdmHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t, _p_ext__shared_ptrT_FdmHestonHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TripleBandLinearOp_t, _p_ext__shared_ptrT_TripleBandLinearOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NinePointLinearOp_t, _p_ext__shared_ptrT_NinePointLinearOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLinearOp_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmZabrOp_t, _p_ext__shared_ptrT_FdmZabrOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSabrOp_t, _p_ext__shared_ptrT_FdmSabrOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesOp_t, _p_ext__shared_ptrT_FdmBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, _p_ext__shared_ptrT_Fdm2dBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBatesOp_t, _p_ext__shared_ptrT_FdmBatesOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLocalVolFwdOp_t, _p_ext__shared_ptrT_FdmLocalVolFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, _p_ext__shared_ptrT_FdmBlackScholesFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSquareRootFwdOp_t, _p_ext__shared_ptrT_FdmSquareRootFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonFwdOp_t, _p_ext__shared_ptrT_FdmHestonFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SecondDerivativeOp_t, _p_ext__shared_ptrT_SecondDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FirstDerivativeOp_t, _p_ext__shared_ptrT_FirstDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t, _p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmG2Op_t, _p_ext__shared_ptrT_FdmG2Op_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NthOrderDerivativeOp_t, _p_ext__shared_ptrT_NthOrderDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmLinearOpComposite_t, _p_ext__shared_ptrT_FdmLinearOpComposite_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmHestonOp_t, _p_ext__shared_ptrT_FdmHestonOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, _p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmDupire1dOp_t, _p_ext__shared_ptrT_FdmDupire1dOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLocalVolFwdOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLocalVolFwdOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLogBasketInnerValue_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLogBasketInnerValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmLogInnerValue_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmLogInnerValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmMesherComposite_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmMesherComposite_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmMesher_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmMesherComposite_t, _p_ext__shared_ptrT_FdmMesherComposite_tTo_p_ext__shared_ptrT_FdmMesher_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmNdimSolverT_4_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmNdimSolverT_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmNdimSolverT_5_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmNdimSolverT_5_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmNdimSolverT_6_t_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmNdimSolverT_6_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmQuantoHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmQuantoHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmSabrOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmSabrOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmSimpleStorageCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmSimpleStorageCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmSimpleSwingCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmSimpleSwingCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmSnapshotCondition_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmSnapshotCondition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmSquareRootFwdOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmSquareRootFwdOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmStepConditionComposite_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmStepConditionComposite_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmStepConditionProxy_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmStepConditionProxy_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmZabrOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmZabrOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FdmZeroInnerValue_t[] = {  {&_swigt__p_ext__shared_ptrT_FdmZeroInnerValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FedFunds_t[] = {  {&_swigt__p_ext__shared_ptrT_FedFunds_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FirstDerivativeOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FirstDerivativeOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FittedBondDiscountCurve_t[] = {  {&_swigt__p_ext__shared_ptrT_FittedBondDiscountCurve_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FixedDividend_t[] = {  {&_swigt__p_ext__shared_ptrT_FixedDividend_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FixedRateBondForward_t[] = {  {&_swigt__p_ext__shared_ptrT_FixedRateBondForward_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FixedRateBondHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_FixedRateBondHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FixedRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_FixedRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FixedRateCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_FixedRateCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FlatForward_t[] = {  {&_swigt__p_ext__shared_ptrT_FlatForward_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FlatHazardRate_t[] = {  {&_swigt__p_ext__shared_ptrT_FlatHazardRate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FlatSmileSection_t[] = {  {&_swigt__p_ext__shared_ptrT_FlatSmileSection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FloatFloatSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_FloatFloatSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FloatFloatSwaption_t[] = {  {&_swigt__p_ext__shared_ptrT_FloatFloatSwaption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FloatingRateBond_t[] = {  {&_swigt__p_ext__shared_ptrT_FloatingRateBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FloatingRateCouponPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborCouponPricer_t, _p_ext__shared_ptrT_IborCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackIborCouponPricer_t, _p_ext__shared_ptrT_BlackIborCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsCouponPricer_t, _p_ext__shared_ptrT_CmsCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticHaganPricer_t, _p_ext__shared_ptrT_AnalyticHaganPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NumericHaganPricer_t, _p_ext__shared_ptrT_NumericHaganPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LinearTsrPricer_t, _p_ext__shared_ptrT_LinearTsrPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsSpreadCouponPricer_t, _p_ext__shared_ptrT_CmsSpreadCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, _p_ext__shared_ptrT_LognormalCmsSpreadPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FloatingRateCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t, _p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t, _p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t, _p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborCoupon_t, _p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsCoupon_t, _p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t, _p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Floor_t[] = {  {&_swigt__p_ext__shared_ptrT_Floor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ForwardEuropeanEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_ForwardEuropeanEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ForwardRateAgreement_t[] = {  {&_swigt__p_ext__shared_ptrT_ForwardRateAgreement_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ForwardVanillaOption_t[] = {  {&_swigt__p_ext__shared_ptrT_ForwardVanillaOption_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t, _p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_ForwardVanillaOption_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Forward_t[] = {  {&_swigt__p_ext__shared_ptrT_ForwardRateAgreement_t, _p_ext__shared_ptrT_ForwardRateAgreement_tTo_p_ext__shared_ptrT_Forward_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Forward_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBondForward_t, _p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_Forward_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FraRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_FraRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FractionalDividend_t[] = {  {&_swigt__p_ext__shared_ptrT_FractionalDividend_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FuturesRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_FuturesRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_FxSwapRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_FxSwapRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_G2ForwardProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_G2ForwardProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_G2Process_t[] = {  {&_swigt__p_ext__shared_ptrT_G2Process_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_G2SwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_G2SwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_G2_t[] = {  {&_swigt__p_ext__shared_ptrT_G2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GBPLiborON_t[] = {  {&_swigt__p_ext__shared_ptrT_GBPLiborON_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GBPLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_GBPLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GBSMRNDCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_GBSMRNDCalculator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GJRGARCHModel_t[] = {  {&_swigt__p_ext__shared_ptrT_GJRGARCHModel_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GJRGARCHProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_GJRGARCHProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GMRES_t[] = {  {&_swigt__p_ext__shared_ptrT_GMRES_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GapPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_GapPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GarmanKohlagenProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Gaussian1dModel_t[] = {  {&_swigt__p_ext__shared_ptrT_Gsr_t, _p_ext__shared_ptrT_Gsr_tTo_p_ext__shared_ptrT_Gaussian1dModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dModel_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_MarkovFunctional_t, _p_ext__shared_ptrT_MarkovFunctional_tTo_p_ext__shared_ptrT_Gaussian1dModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GaussianSimulatedAnnealing_t[] = {  {&_swigt__p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t[] = {  {&_swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackScholesProcess_t, _p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t, _p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackProcess_t, _p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t, _p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t[] = {  {&_swigt__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Glued1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_Glued1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_GsrProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_GsrProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Gsr_t[] = {  {&_swigt__p_ext__shared_ptrT_Gsr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HestonBlackVolSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HestonModelHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_HestonModelHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HestonModel_t[] = {  {&_swigt__p_ext__shared_ptrT_HestonModel_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesModel_t, _p_ext__shared_ptrT_BatesModel_tTo_p_ext__shared_ptrT_HestonModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HestonProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_HestonProcess_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesProcess_t, _p_ext__shared_ptrT_BatesProcess_tTo_p_ext__shared_ptrT_HestonProcess_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HestonRNDCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_HestonRNDCalculator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HestonSLVProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_HestonSLVProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HimalayaOption_t[] = {  {&_swigt__p_ext__shared_ptrT_HimalayaOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HullWhiteForwardProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_HullWhiteForwardProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HullWhiteProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_HullWhiteProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HullWhite_t[] = {  {&_swigt__p_ext__shared_ptrT_HullWhite_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_HundsdorferScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_HundsdorferScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IborCouponPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_IborCouponPricer_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackIborCouponPricer_t, _p_ext__shared_ptrT_BlackIborCouponPricer_tTo_p_ext__shared_ptrT_IborCouponPricer_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IborCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_IborCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IborIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor3W_t, _p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_8M_t, _p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1Y_t, _p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndex_t, _p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor9M_t, _p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor9M_t, _p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor9M_t, _p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3M_t, _p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw5M_t, _p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BiborSW_t, _p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSW_t, _p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLiborSW_t, _p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm6M_t, _p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor4M_t, _p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor4M_t, _p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_THBFIX_t, _p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm1M_t, _p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2W_t, _p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2W_t, _p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_7M_t, _p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sofr_t, _p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Robor_t, _p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2M_t, _p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor8M_t, _p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor8M_t, _p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw4M_t, _p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLiborON_t, _p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLiborON_t, _p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLiborON_t, _p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm5M_t, _p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1Y_t, _p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1Y_t, _p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1Y_t, _p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor_t, _p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Zibor_t, _p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLibor_t, _p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TRLibor_t, _p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Tibor_t, _p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Shibor_t, _p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SEKLibor_t, _p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Pribor_t, _p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NZDLibor_t, _p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor_t, _p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Libor_t, _p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DailyTenorLibor_t, _p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUDLibor_t, _p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLibor_t, _p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CHFLibor_t, _p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DKKLibor_t, _p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JPYLibor_t, _p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLibor_t, _p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor_t, _p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3M_t, _p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor3M_t, _p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor3M_t, _p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Jibar_t, _p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Nzocr_t, _p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_11M_t, _p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_6M_t, _p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor7M_t, _p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor7M_t, _p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1M_t, _p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw3M_t, _p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm4M_t, _p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2M_t, _p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2M_t, _p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor2M_t, _p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_10M_t, _p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_5M_t, _p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor11M_t, _p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor11M_t, _p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Wibor_t, _p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3W_t, _p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cdor_t, _p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor6M_t, _p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor6M_t, _p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor6M_t, _p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_t, _p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw2M_t, _p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm3M_t, _p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_9M_t, _p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw_t, _p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FedFunds_t, _p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1M_t, _p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1M_t, _p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1M_t, _p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_SW_t, _p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm_t, _p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_4M_t, _p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sonia_t, _p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Eonia_t, _p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Aonia_t, _p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw6M_t, _p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor10M_t, _p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor10M_t, _p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Mosprime_t, _p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2W_t, _p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor5M_t, _p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor5M_t, _p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw1M_t, _p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm2M_t, _p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_IborIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ImplicitEulerScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_ImplicitEulerScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ImpliedTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_ImpliedTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Index_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor3W_t, _p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_8M_t, _p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t, _p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t, _p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UKRPI_t, _p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPI_t, _p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1Y_t, _p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, _p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, _p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationIndex_t, _p_ext__shared_ptrT_YoYInflationIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Index_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationIndex_t, _p_ext__shared_ptrT_ZeroInflationIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationIndex_t, _p_ext__shared_ptrT_InflationIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, _p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterestRateIndex_t, _p_ext__shared_ptrT_InterestRateIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborIndex_t, _p_ext__shared_ptrT_IborIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndex_t, _p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor9M_t, _p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor9M_t, _p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor9M_t, _p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3M_t, _p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapIndex_t, _p_ext__shared_ptrT_SwapIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapSpreadIndex_t, _p_ext__shared_ptrT_SwapSpreadIndex_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw5M_t, _p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLiborSW_t, _p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSW_t, _p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BiborSW_t, _p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm6M_t, _p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor4M_t, _p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor4M_t, _p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_THBFIX_t, _p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm1M_t, _p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2W_t, _p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2W_t, _p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_7M_t, _p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPI_t, _p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZACPI_t, _p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sofr_t, _p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Robor_t, _p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2M_t, _p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor8M_t, _p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor8M_t, _p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPIr_t, _p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw4M_t, _p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLiborON_t, _p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLiborON_t, _p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLiborON_t, _p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm5M_t, _p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1Y_t, _p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1Y_t, _p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1Y_t, _p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor_t, _p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLibor_t, _p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JPYLibor_t, _p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DKKLibor_t, _p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CHFLibor_t, _p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLibor_t, _p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUDLibor_t, _p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DailyTenorLibor_t, _p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Libor_t, _p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor_t, _p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NZDLibor_t, _p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Pribor_t, _p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SEKLibor_t, _p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Shibor_t, _p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Tibor_t, _p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TRLibor_t, _p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLibor_t, _p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Zibor_t, _p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor_t, _p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor3M_t, _p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3M_t, _p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor3M_t, _p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Jibar_t, _p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Nzocr_t, _p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_11M_t, _p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_6M_t, _p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPI_t, _p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USCPI_t, _p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor7M_t, _p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor7M_t, _p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1M_t, _p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPXT_t, _p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICPXT_t, _p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw3M_t, _p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm4M_t, _p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2M_t, _p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2M_t, _p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor2M_t, _p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPIr_t, _p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPIr_t, _p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICP_t, _p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICP_t, _p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_10M_t, _p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_5M_t, _p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor11M_t, _p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor11M_t, _p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Wibor_t, _p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3W_t, _p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cdor_t, _p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor6M_t, _p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor6M_t, _p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor6M_t, _p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_t, _p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw2M_t, _p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm3M_t, _p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_9M_t, _p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw_t, _p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FedFunds_t, _p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1M_t, _p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUCPI_t, _p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1M_t, _p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1M_t, _p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_SW_t, _p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPr_t, _p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICPr_t, _p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm_t, _p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_4M_t, _p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sonia_t, _p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Eonia_t, _p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Aonia_t, _p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw6M_t, _p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor10M_t, _p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor10M_t, _p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Mosprime_t, _p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2W_t, _p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor5M_t, _p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor5M_t, _p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw1M_t, _p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICP_t, _p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FRHICP_t, _p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_Index_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm2M_t, _p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_Index_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IndexedCashFlow_t[] = {  {&_swigt__p_ext__shared_ptrT_IndexedCashFlow_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InflationCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_InflationCoupon_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPICoupon_t, _p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_InflationCoupon_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InflationIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationIndex_t, _p_ext__shared_ptrT_YoYInflationIndex_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationIndex_t, _p_ext__shared_ptrT_ZeroInflationIndex_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPI_t, _p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USCPI_t, _p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPIr_t, _p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZACPI_t, _p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICP_t, _p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICP_t, _p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPI_t, _p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPI_t, _p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UKRPI_t, _p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPXT_t, _p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICPXT_t, _p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUCPI_t, _p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPIr_t, _p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPIr_t, _p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICP_t, _p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FRHICP_t, _p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPr_t, _p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICPr_t, _p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_InflationIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InflationTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationTermStructure_t, _p_ext__shared_ptrT_YoYInflationTermStructure_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationTermStructure_t, _p_ext__shared_ptrT_ZeroInflationTermStructure_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Instrument_t[] = {  {&_swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, _p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationFloor_t, _p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloor_t, _p_ext__shared_ptrT_YoYInflationCapFloor_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloor_t, _p_ext__shared_ptrT_CapFloor_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Floor_t, _p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Instrument_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_CompositeInstrument_t, _p_ext__shared_ptrT_CompositeInstrument_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardRateAgreement_t, _p_ext__shared_ptrT_ForwardRateAgreement_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, _p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, _p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponBond_t, _p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t, _p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneAssetOption_t, _p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaOption_t, _p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuropeanOption_t, _p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardVanillaOption_t, _p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoVanillaOption_t, _p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t, _p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HimalayaOption_t, _p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EverestOption_t, _p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BasketOption_t, _p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadOption_t, _p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MultiAssetOption_t, _p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendVanillaOption_t, _p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BarrierOption_t, _p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendBarrierOption_t, _p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CdsOption_t, _p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Swaption_t, _p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NonstandardSwaption_t, _p_ext__shared_ptrT_NonstandardSwaption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatFloatSwaption_t, _p_ext__shared_ptrT_FloatFloatSwaption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwingOption_t, _p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, _p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DoubleBarrierOption_t, _p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, _p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Option_t, _p_ext__shared_ptrT_Option_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCollar_t, _p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Collar_t, _p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCap_t, _p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bond_t, _p_ext__shared_ptrT_Bond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, _p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPIBond_t, _p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableFixedRateBond_t, _p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableBond_t, _p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsRateBond_t, _p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatingRateBond_t, _p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingFloatingRateBond_t, _p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingFixedRateBond_t, _p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBond_t, _p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwap_t, _p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwap_t, _p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwap_t, _p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatFloatSwap_t, _p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AssetSwap_t, _p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NonstandardSwap_t, _p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CreditDefaultSwap_t, _p_ext__shared_ptrT_CreditDefaultSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cap_t, _p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Stock_t, _p_ext__shared_ptrT_Stock_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Swap_t, _p_ext__shared_ptrT_Swap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwap_t, _p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPISwap_t, _p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Forward_t, _p_ext__shared_ptrT_Forward_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBondForward_t, _p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_Instrument_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IntegralCdsEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_IntegralCdsEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IntegralEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_IntegralEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterestRateIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_Euribor3W_t, _p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_8M_t, _p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t, _p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t, _p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1Y_t, _p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, _p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, _p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndex_t, _p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborIndex_t, _p_ext__shared_ptrT_IborIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, _p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterestRateIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor9M_t, _p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor9M_t, _p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor9M_t, _p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3M_t, _p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapIndex_t, _p_ext__shared_ptrT_SwapIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapSpreadIndex_t, _p_ext__shared_ptrT_SwapSpreadIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw5M_t, _p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BiborSW_t, _p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSW_t, _p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLiborSW_t, _p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm6M_t, _p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor4M_t, _p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor4M_t, _p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_THBFIX_t, _p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm1M_t, _p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2W_t, _p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2W_t, _p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_7M_t, _p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sofr_t, _p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Robor_t, _p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2M_t, _p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor8M_t, _p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor8M_t, _p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw4M_t, _p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLiborON_t, _p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLiborON_t, _p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLiborON_t, _p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm5M_t, _p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1Y_t, _p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1Y_t, _p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1Y_t, _p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SEKLibor_t, _p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Pribor_t, _p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NZDLibor_t, _p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor_t, _p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Libor_t, _p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DailyTenorLibor_t, _p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUDLibor_t, _p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLibor_t, _p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CHFLibor_t, _p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DKKLibor_t, _p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JPYLibor_t, _p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLibor_t, _p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor_t, _p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Shibor_t, _p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Tibor_t, _p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TRLibor_t, _p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLibor_t, _p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Zibor_t, _p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor_t, _p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3M_t, _p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor3M_t, _p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor3M_t, _p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Jibar_t, _p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Nzocr_t, _p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_11M_t, _p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_6M_t, _p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor7M_t, _p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor7M_t, _p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1M_t, _p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw3M_t, _p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm4M_t, _p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2M_t, _p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2M_t, _p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor2M_t, _p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_10M_t, _p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_5M_t, _p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor11M_t, _p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor11M_t, _p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Wibor_t, _p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3W_t, _p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cdor_t, _p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor6M_t, _p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor6M_t, _p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor6M_t, _p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_t, _p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw2M_t, _p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm3M_t, _p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_9M_t, _p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw_t, _p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FedFunds_t, _p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1M_t, _p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1M_t, _p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1M_t, _p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_SW_t, _p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm_t, _p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_4M_t, _p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Aonia_t, _p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Eonia_t, _p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sonia_t, _p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw6M_t, _p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor10M_t, _p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor10M_t, _p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Mosprime_t, _p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2W_t, _p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor5M_t, _p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor5M_t, _p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw1M_t, _p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm2M_t, _p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_IsdaCdsEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_IsdaCdsEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_JPYLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_JPYLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_JamshidianSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_JamshidianSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Jibar_t[] = {  {&_swigt__p_ext__shared_ptrT_Jibar_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t[] = {  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t[] = {  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_KahaleSmileSection_t[] = {  {&_swigt__p_ext__shared_ptrT_KahaleSmileSection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_KerkhofSeasonality_t[] = {  {&_swigt__p_ext__shared_ptrT_KerkhofSeasonality_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_KirkEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_KirkEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_KirkSpreadOptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_KirkSpreadOptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_KlugeExtOUProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_KlugeExtOUProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LevenbergMarquardt_t[] = {  {&_swigt__p_ext__shared_ptrT_LevenbergMarquardt_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Libor_t[] = {  {&_swigt__p_ext__shared_ptrT_Libor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LinearTsrPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_LinearTsrPricer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LocalConstantVol_t[] = {  {&_swigt__p_ext__shared_ptrT_LocalConstantVol_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LocalVolRNDCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_LocalVolRNDCalculator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LocalVolSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_LocalVolSurface_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t, _p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolSurface_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LocalVolTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_LocalVolSurface_t, _p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t, _p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalConstantVol_t, _p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, _p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t[] = {  {&_swigt__p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t[] = {  {&_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MTBrownianGeneratorFactory_t[] = {  {&_swigt__p_ext__shared_ptrT_MTBrownianGeneratorFactory_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MarkovFunctional_t[] = {  {&_swigt__p_ext__shared_ptrT_MarkovFunctional_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MaxBasketPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_MaxBasketPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Merton76Process_t[] = {  {&_swigt__p_ext__shared_ptrT_Merton76Process_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MethodOfLinesScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_MethodOfLinesScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MidPointCdsEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_MidPointCdsEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MinBasketPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_MinBasketPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t[] = {  {&_swigt__p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ModifiedCraigSneydScheme_t[] = {  {&_swigt__p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Mosprime_t[] = {  {&_swigt__p_ext__shared_ptrT_Mosprime_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MultiAssetOption_t[] = {  {&_swigt__p_ext__shared_ptrT_MultiAssetOption_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadOption_t, _p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BasketOption_t, _p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EverestOption_t, _p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HimalayaOption_t, _p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_MultiplicativePriceSeasonality_t[] = {  {&_swigt__p_ext__shared_ptrT_MultiplicativePriceSeasonality_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NZDLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_NZDLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NeumannBC_t[] = {  {&_swigt__p_ext__shared_ptrT_NeumannBC_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NinePointLinearOp_t[] = {  {&_swigt__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t, _p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_tTo_p_ext__shared_ptrT_NinePointLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NinePointLinearOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t[] = {  {&_swigt__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NoArbSabrSmileSection_t[] = {  {&_swigt__p_ext__shared_ptrT_NoArbSabrSmileSection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NoConstraint_t[] = {  {&_swigt__p_ext__shared_ptrT_NoConstraint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NoExceptLocalVolSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t[] = {  {&_swigt__p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NonstandardSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_NonstandardSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NonstandardSwaption_t[] = {  {&_swigt__p_ext__shared_ptrT_NonstandardSwaption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NthOrderDerivativeOp_t[] = {  {&_swigt__p_ext__shared_ptrT_NthOrderDerivativeOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_NumericHaganPricer_t[] = {  {&_swigt__p_ext__shared_ptrT_NumericHaganPricer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Nzocr_t[] = {  {&_swigt__p_ext__shared_ptrT_Nzocr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OISRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_OISRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Observable_t[] = {  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, _p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Robor_t, _p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t, _p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t, _p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BiborSW_t, _p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSW_t, _p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLiborSW_t, _p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICP_t, _p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FRHICP_t, _p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICP_t, _p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICP_t, _p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloor_t, _p_ext__shared_ptrT_YoYInflationCapFloor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationFloor_t, _p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloor_t, _p_ext__shared_ptrT_CapFloor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Floor_t, _p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatForward_t, _p_ext__shared_ptrT_FlatForward_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatForward_t, _p_ext__shared_ptrT_PiecewiseFlatForward_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearForward_t, _p_ext__shared_ptrT_PiecewiseLinearForward_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Forward_t, _p_ext__shared_ptrT_Forward_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBondForward_t, _p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, _p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, _p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Instrument_t, _p_ext__shared_ptrT_Instrument_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CompositeInstrument_t, _p_ext__shared_ptrT_CompositeInstrument_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingPayment_t, _p_ext__shared_ptrT_AmortizingPayment_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardRateAgreement_t, _p_ext__shared_ptrT_ForwardRateAgreement_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gsr_t, _p_ext__shared_ptrT_Gsr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Observable_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3W_t, _p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2W_t, _p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2W_t, _p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t, _p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICPXT_t, _p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPXT_t, _p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackConstantVol_t, _p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalConstantVol_t, _p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor9M_t, _p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor9M_t, _p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor9M_t, _p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor8M_t, _p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor8M_t, _p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor7M_t, _p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor7M_t, _p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor6M_t, _p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor6M_t, _p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor6M_t, _p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor5M_t, _p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor5M_t, _p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, _p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor4M_t, _p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor4M_t, _p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor3M_t, _p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor3M_t, _p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor3M_t, _p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor2M_t, _p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor2M_t, _p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor2M_t, _p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1M_t, _p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1M_t, _p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1M_t, _p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UKRPI_t, _p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPI_t, _p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor11M_t, _p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor11M_t, _p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor10M_t, _p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor10M_t, _p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLiborON_t, _p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLiborON_t, _p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLiborON_t, _p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, _p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, _p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t, _p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, _p_ext__shared_ptrT_GeometricBrownianMotionProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, _p_ext__shared_ptrT_GeneralizedBlackScholesProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, _p_ext__shared_ptrT_DefaultProbabilityTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, _p_ext__shared_ptrT_CapFloorTermVolatilityStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, _p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t, _p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t, _p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sonia_t, _p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Eonia_t, _p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Aonia_t, _p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneFactorAffineModel_t, _p_ext__shared_ptrT_OneFactorAffineModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ShortRateModel_t, _p_ext__shared_ptrT_ShortRateModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CalibratedModel_t, _p_ext__shared_ptrT_CalibratedModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dModel_t, _p_ext__shared_ptrT_Gaussian1dModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TermStructureConsistentModel_t, _p_ext__shared_ptrT_TermStructureConsistentModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonModel_t, _p_ext__shared_ptrT_HestonModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesModel_t, _p_ext__shared_ptrT_BatesModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GJRGARCHModel_t, _p_ext__shared_ptrT_GJRGARCHModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_SW_t, _p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t, _p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor1Y_t, _p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor1Y_t, _p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor1Y_t, _p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw6M_t, _p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw5M_t, _p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw4M_t, _p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw3M_t, _p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, _p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw2M_t, _p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MarkovFunctional_t, _p_ext__shared_ptrT_MarkovFunctional_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw1M_t, _p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, _p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CashFlow_t, _p_ext__shared_ptrT_CashFlow_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SimpleCashFlow_t, _p_ext__shared_ptrT_SimpleCashFlow_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IndexedCashFlow_t, _p_ext__shared_ptrT_IndexedCashFlow_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, _p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, _p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, _p_ext__shared_ptrT_PiecewiseLogCubicDiscount_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, _p_ext__shared_ptrT_PiecewiseLogLinearDiscount_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cap_t, _p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCollar_t, _p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Collar_t, _p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, _p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t, _p_ext__shared_ptrT_JuQuadraticApproximationEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, _p_ext__shared_ptrT_ExponentialFittingHestonEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, _p_ext__shared_ptrT_SwaptionVolCube1_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3W_t, _p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2W_t, _p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearZero_t, _p_ext__shared_ptrT_PiecewiseLinearZero_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerZero_t, _p_ext__shared_ptrT_PiecewiseKrugerZero_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t, _p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseCubicZero_t, _p_ext__shared_ptrT_PiecewiseCubicZero_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, _p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sofr_t, _p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FedFunds_t, _p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_9M_t, _p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_8M_t, _p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Dividend_t, _p_ext__shared_ptrT_Dividend_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedDividend_t, _p_ext__shared_ptrT_FixedDividend_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FractionalDividend_t, _p_ext__shared_ptrT_FractionalDividend_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_7M_t, _p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_6M_t, _p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_5M_t, _p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t, _p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_4M_t, _p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_3M_t, _p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_2M_t, _p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwap_t, _p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwap_t, _p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwap_t, _p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatFloatSwap_t, _p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AssetSwap_t, _p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NonstandardSwap_t, _p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CreditDefaultSwap_t, _p_ext__shared_ptrT_CreditDefaultSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Swap_t, _p_ext__shared_ptrT_Swap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwap_t, _p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPISwap_t, _p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1M_t, _p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ImpliedTermStructure_t, _p_ext__shared_ptrT_ImpliedTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, _p_ext__shared_ptrT_ZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, _p_ext__shared_ptrT_ForwardSpreadedTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YieldTermStructure_t, _p_ext__shared_ptrT_YieldTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TermStructure_t, _p_ext__shared_ptrT_TermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VolatilityTermStructure_t, _p_ext__shared_ptrT_VolatilityTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVolTermStructure_t, _p_ext__shared_ptrT_BlackVolTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolTermStructure_t, _p_ext__shared_ptrT_LocalVolTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OptionletVolatilityStructure_t, _p_ext__shared_ptrT_OptionletVolatilityStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityStructure_t, _p_ext__shared_ptrT_SwaptionVolatilityStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationTermStructure_t, _p_ext__shared_ptrT_InflationTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationTermStructure_t, _p_ext__shared_ptrT_YoYInflationTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationTermStructure_t, _p_ext__shared_ptrT_ZeroInflationTermStructure_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, _p_ext__shared_ptrT_SwaptionVolCube2_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoArbSabrSmileSection_t, _p_ext__shared_ptrT_NoArbSabrSmileSection_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SmileSection_t, _p_ext__shared_ptrT_SmileSection_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SabrSmileSection_t, _p_ext__shared_ptrT_SabrSmileSection_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatSmileSection_t, _p_ext__shared_ptrT_FlatSmileSection_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KahaleSmileSection_t, _p_ext__shared_ptrT_KahaleSmileSection_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Redemption_t, _p_ext__shared_ptrT_Redemption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Option_t, _p_ext__shared_ptrT_Option_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, _p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DoubleBarrierOption_t, _p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, _p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwingOption_t, _p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneAssetOption_t, _p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaOption_t, _p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuropeanOption_t, _p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardVanillaOption_t, _p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoVanillaOption_t, _p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t, _p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HimalayaOption_t, _p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EverestOption_t, _p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BasketOption_t, _p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadOption_t, _p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MultiAssetOption_t, _p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendVanillaOption_t, _p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BarrierOption_t, _p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendBarrierOption_t, _p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CdsOption_t, _p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Swaption_t, _p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NonstandardSwaption_t, _p_ext__shared_ptrT_NonstandardSwaption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatFloatSwaption_t, _p_ext__shared_ptrT_FloatFloatSwaption_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, _p_ext__shared_ptrT_YoYOptionletVolatilitySurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndex_t, _p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborIndex_t, _p_ext__shared_ptrT_IborIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, _p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterestRateIndex_t, _p_ext__shared_ptrT_InterestRateIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapIndex_t, _p_ext__shared_ptrT_SwapIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapSpreadIndex_t, _p_ext__shared_ptrT_SwapSpreadIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Index_t, _p_ext__shared_ptrT_Index_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationIndex_t, _p_ext__shared_ptrT_YoYInflationIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationIndex_t, _p_ext__shared_ptrT_ZeroInflationIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationIndex_t, _p_ext__shared_ptrT_InflationIndex_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t, _p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t, _p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t, _p_ext__shared_ptrT_YearOnYearInflationSwapHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, _p_ext__shared_ptrT_ExtendedCoxIngersollRoss_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CoxIngersollRoss_t, _p_ext__shared_ptrT_CoxIngersollRoss_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Wibor_t, _p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPI_t, _p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZACPI_t, _p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, _p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EURLibor_t, _p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBPLibor_t, _p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JPYLibor_t, _p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DKKLibor_t, _p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CHFLibor_t, _p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CADLibor_t, _p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUDLibor_t, _p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DailyTenorLibor_t, _p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Libor_t, _p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor_t, _p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NZDLibor_t, _p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Pribor_t, _p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SEKLibor_t, _p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Shibor_t, _p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Tibor_t, _p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TRLibor_t, _p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USDLibor_t, _p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Zibor_t, _p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bibor_t, _p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, _p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_1Y_t, _p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPIr_t, _p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, _p_ext__shared_ptrT_PiecewiseFlatHazardRate_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatHazardRate_t, _p_ext__shared_ptrT_FlatHazardRate_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, _p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, _p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_THBFIX_t, _p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Jibar_t, _p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackKarasinski_t, _p_ext__shared_ptrT_BlackKarasinski_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, _p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, _p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableZeroCouponBond_t, _p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponBond_t, _p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, _p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FittedBondDiscountCurve_t, _p_ext__shared_ptrT_FittedBondDiscountCurve_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceCurve_t, _p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t, _p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPr_t, _p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICPr_t, _p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bond_t, _p_ext__shared_ptrT_Bond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, _p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPIBond_t, _p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableFixedRateBond_t, _p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CallableBond_t, _p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsRateBond_t, _p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatingRateBond_t, _p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingFloatingRateBond_t, _p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AmortizingFixedRateBond_t, _p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBond_t, _p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Stock_t, _p_ext__shared_ptrT_Stock_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, _p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t, _p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t, _p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bbsw_t, _p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t, _p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUCPI_t, _p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPICoupon_t, _p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationCoupon_t, _p_ext__shared_ptrT_InflationCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsSpreadCoupon_t, _p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CmsCoupon_t, _p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IborCoupon_t, _p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, _p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredIborCoupon_t, _p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CappedFlooredCoupon_t, _p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t, _p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatingRateCoupon_t, _p_ext__shared_ptrT_FloatingRateCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateCoupon_t, _p_ext__shared_ptrT_FixedRateCoupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Coupon_t, _p_ext__shared_ptrT_Coupon_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_t, _p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t, _p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, _p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t, _p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhite_t, _p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Nzocr_t, _p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, _p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, _p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t, _p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceSurface_t, _p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t, _p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolSurface_t, _p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t, _p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, _p_ext__shared_ptrT_OvernightIndexFutureRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, _p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t, _p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Mosprime_t, _p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Vasicek_t, _p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t, _p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t, _p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm6M_t, _p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcess1D_t, _p_ext__shared_ptrT_StochasticProcess1D_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BachelierSwaptionEngine_t, _p_ext__shared_ptrT_BachelierSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackSwaptionEngine_t, _p_ext__shared_ptrT_BlackSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCdsOptionEngine_t, _p_ext__shared_ptrT_BlackCdsOptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IsdaCdsEngine_t, _p_ext__shared_ptrT_IsdaCdsEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IntegralCdsEngine_t, _p_ext__shared_ptrT_IntegralCdsEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MidPointCdsEngine_t, _p_ext__shared_ptrT_MidPointCdsEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BachelierCapFloorEngine_t, _p_ext__shared_ptrT_BachelierCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCapFloorEngine_t, _p_ext__shared_ptrT_BlackCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscountingBondEngine_t, _p_ext__shared_ptrT_DiscountingBondEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t, _p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, _p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdG2SwaptionEngine_t, _p_ext__shared_ptrT_FdG2SwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2SwaptionEngine_t, _p_ext__shared_ptrT_G2SwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TreeCapFloorEngine_t, _p_ext__shared_ptrT_TreeCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticCapFloorEngine_t, _p_ext__shared_ptrT_AnalyticCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TreeSwaptionEngine_t, _p_ext__shared_ptrT_TreeSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JamshidianSwaptionEngine_t, _p_ext__shared_ptrT_JamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscountingSwapEngine_t, _p_ext__shared_ptrT_DiscountingSwapEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KirkEngine_t, _p_ext__shared_ptrT_KirkEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StulzEngine_t, _p_ext__shared_ptrT_StulzEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KirkSpreadOptionEngine_t, _p_ext__shared_ptrT_KirkSpreadOptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PricingEngine_t, _p_ext__shared_ptrT_PricingEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t, _p_ext__shared_ptrT_AnalyticGJRGARCHEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, _p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, _p_ext__shared_ptrT_FdSimpleBSSwingEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, _p_ext__shared_ptrT_VannaVolgaBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonBarrierEngine_t, _p_ext__shared_ptrT_FdHestonBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonRebateEngine_t, _p_ext__shared_ptrT_FdHestonRebateEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t, _p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardEuropeanEngine_t, _p_ext__shared_ptrT_ForwardEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoEuropeanEngine_t, _p_ext__shared_ptrT_QuantoEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t, _p_ext__shared_ptrT_QuantoForwardEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VarianceGammaEngine_t, _p_ext__shared_ptrT_VarianceGammaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FFTVarianceGammaEngine_t, _p_ext__shared_ptrT_FFTVarianceGammaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, _p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, _p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t, _p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, _p_ext__shared_ptrT_FdBlackScholesRebateEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, _p_ext__shared_ptrT_FdBlackScholesBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdSabrVanillaEngine_t, _p_ext__shared_ptrT_FdSabrVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdCEVVanillaEngine_t, _p_ext__shared_ptrT_FdCEVVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticCEVEngine_t, _p_ext__shared_ptrT_AnalyticCEVEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonVanillaEngine_t, _p_ext__shared_ptrT_FdHestonVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBatesVanillaEngine_t, _p_ext__shared_ptrT_FdBatesVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, _p_ext__shared_ptrT_FdBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticBarrierEngine_t, _p_ext__shared_ptrT_AnalyticBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IntegralEngine_t, _p_ext__shared_ptrT_IntegralEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesEngine_t, _p_ext__shared_ptrT_BatesEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, _p_ext__shared_ptrT_AnalyticPTDHestonEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_COSHestonEngine_t, _p_ext__shared_ptrT_COSHestonEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticHestonEngine_t, _p_ext__shared_ptrT_AnalyticHestonEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticEuropeanEngine_t, _p_ext__shared_ptrT_AnalyticEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t, _p_ext__shared_ptrT_FdBlackScholesAsianEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm5M_t, _p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm4M_t, _p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm3M_t, _p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcessArray_t, _p_ext__shared_ptrT_StochasticProcessArray_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm2M_t, _p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, _p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm1M_t, _p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPI_t, _p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_USCPI_t, _p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, _p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t, _p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t, _p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackProcess_t, _p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t, _p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackScholesProcess_t, _p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, _p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GsrProcess_t, _p_ext__shared_ptrT_GsrProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhiteForwardProcess_t, _p_ext__shared_ptrT_HullWhiteForwardProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhiteProcess_t, _p_ext__shared_ptrT_HullWhiteProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VarianceGammaProcess_t, _p_ext__shared_ptrT_VarianceGammaProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Merton76Process_t, _p_ext__shared_ptrT_Merton76Process_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonSLVProcess_t, _p_ext__shared_ptrT_HestonSLVProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcess_t, _p_ext__shared_ptrT_StochasticProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonProcess_t, _p_ext__shared_ptrT_HestonProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesProcess_t, _p_ext__shared_ptrT_BatesProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2Process_t, _p_ext__shared_ptrT_G2Process_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2ForwardProcess_t, _p_ext__shared_ptrT_G2ForwardProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, _p_ext__shared_ptrT_ExtOUWithJumpsProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KlugeExtOUProcess_t, _p_ext__shared_ptrT_KlugeExtOUProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GJRGARCHProcess_t, _p_ext__shared_ptrT_GJRGARCHProcess_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Bkbm_t, _p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Cdor_t, _p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t, _p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCap_t, _p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2_t, _p_ext__shared_ptrT_G2_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DeltaVolQuote_t, _p_ext__shared_ptrT_DeltaVolQuote_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SimpleQuote_t, _p_ext__shared_ptrT_SimpleQuote_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Quote_t, _p_ext__shared_ptrT_Quote_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t, _p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_11M_t, _p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletHelper_t, _p_ext__shared_ptrT_YoYOptionletHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SofrFutureRateHelper_t, _p_ext__shared_ptrT_SofrFutureRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_RateHelper_t, _p_ext__shared_ptrT_RateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DepositRateHelper_t, _p_ext__shared_ptrT_DepositRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FraRateHelper_t, _p_ext__shared_ptrT_FraRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FuturesRateHelper_t, _p_ext__shared_ptrT_FuturesRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapRateHelper_t, _p_ext__shared_ptrT_SwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BondHelper_t, _p_ext__shared_ptrT_BondHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBondHelper_t, _p_ext__shared_ptrT_FixedRateBondHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OISRateHelper_t, _p_ext__shared_ptrT_OISRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DatedOISRateHelper_t, _p_ext__shared_ptrT_DatedOISRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FxSwapRateHelper_t, _p_ext__shared_ptrT_FxSwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DefaultProbabilityHelper_t, _p_ext__shared_ptrT_DefaultProbabilityHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadCdsHelper_t, _p_ext__shared_ptrT_SpreadCdsHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UpfrontCdsHelper_t, _p_ext__shared_ptrT_UpfrontCdsHelper_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Euribor365_10M_t, _p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPIr_t, _p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPIr_t, _p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t, _p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_tTo_p_ext__shared_ptrT_Observable_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OneAssetOption_t[] = {  {&_swigt__p_ext__shared_ptrT_VanillaOption_t, _p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuropeanOption_t, _p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardVanillaOption_t, _p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoVanillaOption_t, _p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t, _p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendVanillaOption_t, _p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BarrierOption_t, _p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendBarrierOption_t, _p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, _p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DoubleBarrierOption_t, _p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, _p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwingOption_t, _p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneAssetOption_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, _p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_OneAssetOption_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OneFactorAffineModel_t[] = {  {&_swigt__p_ext__shared_ptrT_Vasicek_t, _p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_OneFactorAffineModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneFactorAffineModel_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhite_t, _p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_OneFactorAffineModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OptimizationMethod_t[] = {  {&_swigt__p_ext__shared_ptrT_ConjugateGradient_t, _p_ext__shared_ptrT_ConjugateGradient_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SteepestDescent_t, _p_ext__shared_ptrT_SteepestDescent_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OptimizationMethod_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BFGS_t, _p_ext__shared_ptrT_BFGS_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, _p_ext__shared_ptrT_GaussianSimulatedAnnealing_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, _p_ext__shared_ptrT_LogNormalSimulatedAnnealing_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LevenbergMarquardt_t, _p_ext__shared_ptrT_LevenbergMarquardt_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, _p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Simplex_t, _p_ext__shared_ptrT_Simplex_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DifferentialEvolution_t, _p_ext__shared_ptrT_DifferentialEvolution_tTo_p_ext__shared_ptrT_OptimizationMethod_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Option_t[] = {  {&_swigt__p_ext__shared_ptrT_DividendBarrierOption_t, _p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BarrierOption_t, _p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DividendVanillaOption_t, _p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HimalayaOption_t, _p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EverestOption_t, _p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BasketOption_t, _p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SpreadOption_t, _p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MultiAssetOption_t, _p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoVanillaOption_t, _p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t, _p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardVanillaOption_t, _p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuropeanOption_t, _p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaOption_t, _p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Option_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, _p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DoubleBarrierOption_t, _p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, _p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneAssetOption_t, _p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwingOption_t, _p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CdsOption_t, _p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Swaption_t, _p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, _p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_Option_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OptionletStripper1_t[] = {  {&_swigt__p_ext__shared_ptrT_OptionletStripper1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OptionletVolatilityStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t, _p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t, _p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_SofrFutureRateHelper_t, _p_ext__shared_ptrT_SofrFutureRateHelper_tTo_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OvernightIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_Sofr_t, _p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_OvernightIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FedFunds_t, _p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_OvernightIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Nzocr_t, _p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_OvernightIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Aonia_t, _p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_OvernightIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Eonia_t, _p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_OvernightIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Sonia_t, _p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_OvernightIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OvernightIndexedCoupon_t[] = {  {&_swigt__p_ext__shared_ptrT_OvernightIndexedCoupon_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_OvernightIndexedSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Payoff_t[] = {  {&_swigt__p_ext__shared_ptrT_SpreadBasketPayoff_t, _p_ext__shared_ptrT_SpreadBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AverageBasketPayoff_t, _p_ext__shared_ptrT_AverageBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MaxBasketPayoff_t, _p_ext__shared_ptrT_MaxBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MinBasketPayoff_t, _p_ext__shared_ptrT_MinBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BasketPayoff_t, _p_ext__shared_ptrT_BasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaForwardPayoff_t, _p_ext__shared_ptrT_VanillaForwardPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GapPayoff_t, _p_ext__shared_ptrT_GapPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SuperSharePayoff_t, _p_ext__shared_ptrT_SuperSharePayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AssetOrNothingPayoff_t, _p_ext__shared_ptrT_AssetOrNothingPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CashOrNothingPayoff_t, _p_ext__shared_ptrT_CashOrNothingPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PercentageStrikePayoff_t, _p_ext__shared_ptrT_PercentageStrikePayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PlainVanillaPayoff_t, _p_ext__shared_ptrT_PlainVanillaPayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StrikedTypePayoff_t, _p_ext__shared_ptrT_StrikedTypePayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Payoff_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_TypePayoff_t, _p_ext__shared_ptrT_TypePayoff_tTo_p_ext__shared_ptrT_Payoff_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PercentageStrikePayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_PercentageStrikePayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseCubicZero_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseCubicZero_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseFlatForward_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatForward_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseKrugerZero_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseLinearForward_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearForward_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseLinearZero_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearZero_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PlainVanillaPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_PlainVanillaPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PositiveConstraint_t[] = {  {&_swigt__p_ext__shared_ptrT_PositiveConstraint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Predefined1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_Predefined1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Pribor_t[] = {  {&_swigt__p_ext__shared_ptrT_Pribor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_PricingEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t, _p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, _p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t, _p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t, _p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, _p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, _p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, _p_ext__shared_ptrT_ExponentialFittingHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t, _p_ext__shared_ptrT_JuQuadraticApproximationEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t, _p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, _p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t, _p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t, _p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t, _p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t, _p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t, _p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t, _p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, _p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FFTVarianceGammaEngine_t, _p_ext__shared_ptrT_FFTVarianceGammaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VarianceGammaEngine_t, _p_ext__shared_ptrT_VarianceGammaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t, _p_ext__shared_ptrT_QuantoForwardEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_QuantoEuropeanEngine_t, _p_ext__shared_ptrT_QuantoEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardEuropeanEngine_t, _p_ext__shared_ptrT_ForwardEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t, _p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonRebateEngine_t, _p_ext__shared_ptrT_FdHestonRebateEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonBarrierEngine_t, _p_ext__shared_ptrT_FdHestonBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, _p_ext__shared_ptrT_VannaVolgaBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, _p_ext__shared_ptrT_FdSimpleBSSwingEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, _p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t, _p_ext__shared_ptrT_AnalyticGJRGARCHEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KirkSpreadOptionEngine_t, _p_ext__shared_ptrT_KirkSpreadOptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StulzEngine_t, _p_ext__shared_ptrT_StulzEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KirkEngine_t, _p_ext__shared_ptrT_KirkEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscountingSwapEngine_t, _p_ext__shared_ptrT_DiscountingSwapEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JamshidianSwaptionEngine_t, _p_ext__shared_ptrT_JamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TreeSwaptionEngine_t, _p_ext__shared_ptrT_TreeSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticCapFloorEngine_t, _p_ext__shared_ptrT_AnalyticCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TreeCapFloorEngine_t, _p_ext__shared_ptrT_TreeCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2SwaptionEngine_t, _p_ext__shared_ptrT_G2SwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdG2SwaptionEngine_t, _p_ext__shared_ptrT_FdG2SwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, _p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t, _p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DiscountingBondEngine_t, _p_ext__shared_ptrT_DiscountingBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCapFloorEngine_t, _p_ext__shared_ptrT_BlackCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BachelierCapFloorEngine_t, _p_ext__shared_ptrT_BachelierCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MidPointCdsEngine_t, _p_ext__shared_ptrT_MidPointCdsEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IntegralCdsEngine_t, _p_ext__shared_ptrT_IntegralCdsEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IsdaCdsEngine_t, _p_ext__shared_ptrT_IsdaCdsEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackCdsOptionEngine_t, _p_ext__shared_ptrT_BlackCdsOptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackSwaptionEngine_t, _p_ext__shared_ptrT_BlackSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BachelierSwaptionEngine_t, _p_ext__shared_ptrT_BachelierSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PricingEngine_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, _p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t, _p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, _p_ext__shared_ptrT_FdBlackScholesRebateEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, _p_ext__shared_ptrT_FdBlackScholesBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdSabrVanillaEngine_t, _p_ext__shared_ptrT_FdSabrVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdCEVVanillaEngine_t, _p_ext__shared_ptrT_FdCEVVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticCEVEngine_t, _p_ext__shared_ptrT_AnalyticCEVEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdHestonVanillaEngine_t, _p_ext__shared_ptrT_FdHestonVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBatesVanillaEngine_t, _p_ext__shared_ptrT_FdBatesVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, _p_ext__shared_ptrT_FdBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticBarrierEngine_t, _p_ext__shared_ptrT_AnalyticBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_IntegralEngine_t, _p_ext__shared_ptrT_IntegralEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesEngine_t, _p_ext__shared_ptrT_BatesEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, _p_ext__shared_ptrT_AnalyticPTDHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_COSHestonEngine_t, _p_ext__shared_ptrT_COSHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticHestonEngine_t, _p_ext__shared_ptrT_AnalyticHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AnalyticEuropeanEngine_t, _p_ext__shared_ptrT_AnalyticEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t, _p_ext__shared_ptrT_FdBlackScholesAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t, _p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t, _p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, _p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t, _p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t, _p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, _p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t, _p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t, _p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t, _p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, _p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t, _p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, _p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t, _p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_PricingEngine_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t[] = {  {&_swigt__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_QuantoEuropeanEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_QuantoEuropeanEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_QuantoForwardVanillaOption_t[] = {  {&_swigt__p_ext__shared_ptrT_QuantoForwardVanillaOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_QuantoVanillaOption_t[] = {  {&_swigt__p_ext__shared_ptrT_QuantoVanillaOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Quote_t[] = {  {&_swigt__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t, _p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_tTo_p_ext__shared_ptrT_Quote_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Quote_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SimpleQuote_t, _p_ext__shared_ptrT_SimpleQuote_tTo_p_ext__shared_ptrT_Quote_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DeltaVolQuote_t, _p_ext__shared_ptrT_DeltaVolQuote_tTo_p_ext__shared_ptrT_Quote_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t, _p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_tTo_p_ext__shared_ptrT_Quote_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_RateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_RateHelper_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_DepositRateHelper_t, _p_ext__shared_ptrT_DepositRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FraRateHelper_t, _p_ext__shared_ptrT_FraRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FuturesRateHelper_t, _p_ext__shared_ptrT_FuturesRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapRateHelper_t, _p_ext__shared_ptrT_SwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BondHelper_t, _p_ext__shared_ptrT_BondHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FixedRateBondHelper_t, _p_ext__shared_ptrT_FixedRateBondHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OISRateHelper_t, _p_ext__shared_ptrT_OISRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DatedOISRateHelper_t, _p_ext__shared_ptrT_DatedOISRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FxSwapRateHelper_t, _p_ext__shared_ptrT_FxSwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SofrFutureRateHelper_t, _p_ext__shared_ptrT_SofrFutureRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, _p_ext__shared_ptrT_OvernightIndexFutureRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_RebatedExercise_t[] = {  {&_swigt__p_ext__shared_ptrT_RebatedExercise_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Redemption_t[] = {  {&_swigt__p_ext__shared_ptrT_Redemption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_RiskNeutralDensityCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_BSMRNDCalculator_t, _p_ext__shared_ptrT_BSMRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CEVRNDCalculator_t, _p_ext__shared_ptrT_CEVRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GBSMRNDCalculator_t, _p_ext__shared_ptrT_GBSMRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonRNDCalculator_t, _p_ext__shared_ptrT_HestonRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolRNDCalculator_t, _p_ext__shared_ptrT_LocalVolRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, _p_ext__shared_ptrT_SquareRootProcessRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Robor_t[] = {  {&_swigt__p_ext__shared_ptrT_Robor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SEKLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_SEKLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SabrSmileSection_t[] = {  {&_swigt__p_ext__shared_ptrT_SabrSmileSection_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Seasonality_t[] = {  {&_swigt__p_ext__shared_ptrT_Seasonality_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_MultiplicativePriceSeasonality_t, _p_ext__shared_ptrT_MultiplicativePriceSeasonality_tTo_p_ext__shared_ptrT_Seasonality_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KerkhofSeasonality_t, _p_ext__shared_ptrT_KerkhofSeasonality_tTo_p_ext__shared_ptrT_Seasonality_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SecondDerivativeOp_t[] = {  {&_swigt__p_ext__shared_ptrT_SecondDerivativeOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t[] = {  {&_swigt__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Shibor_t[] = {  {&_swigt__p_ext__shared_ptrT_Shibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ShortRateModel_t[] = {  {&_swigt__p_ext__shared_ptrT_Vasicek_t, _p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2_t, _p_ext__shared_ptrT_G2_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ShortRateModel_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhite_t, _p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OneFactorAffineModel_t, _p_ext__shared_ptrT_OneFactorAffineModel_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CoxIngersollRoss_t, _p_ext__shared_ptrT_CoxIngersollRoss_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, _p_ext__shared_ptrT_ExtendedCoxIngersollRoss_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackKarasinski_t, _p_ext__shared_ptrT_BlackKarasinski_tTo_p_ext__shared_ptrT_ShortRateModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SimpleCashFlow_t[] = {  {&_swigt__p_ext__shared_ptrT_SimpleCashFlow_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SimpleQuote_t[] = {  {&_swigt__p_ext__shared_ptrT_SimpleQuote_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Simplex_t[] = {  {&_swigt__p_ext__shared_ptrT_Simplex_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SmileSection_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, _p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KahaleSmileSection_t, _p_ext__shared_ptrT_KahaleSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatSmileSection_t, _p_ext__shared_ptrT_FlatSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SabrSmileSection_t, _p_ext__shared_ptrT_SabrSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoArbSabrSmileSection_t, _p_ext__shared_ptrT_NoArbSabrSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SmileSection_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, _p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, _p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_SmileSection_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t[] = {  {&_swigt__p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SofrFutureRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_SofrFutureRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Sofr_t[] = {  {&_swigt__p_ext__shared_ptrT_Sofr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SoftCallability_t[] = {  {&_swigt__p_ext__shared_ptrT_SoftCallability_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Sonia_t[] = {  {&_swigt__p_ext__shared_ptrT_Sonia_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SpreadBasketPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_SpreadBasketPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SpreadCdsHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_SpreadCdsHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SpreadOption_t[] = {  {&_swigt__p_ext__shared_ptrT_SpreadOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t[] = {  {&_swigt__p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SteepestDescent_t[] = {  {&_swigt__p_ext__shared_ptrT_SteepestDescent_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StepConditionT_Array_t_t[] = {  {&_swigt__p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmArithmeticAverageCondition_t, _p_ext__shared_ptrT_FdmArithmeticAverageCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmStepConditionProxy_t, _p_ext__shared_ptrT_FdmStepConditionProxy_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmStepConditionComposite_t, _p_ext__shared_ptrT_FdmStepConditionComposite_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSnapshotCondition_t, _p_ext__shared_ptrT_FdmSnapshotCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmAmericanStepCondition_t, _p_ext__shared_ptrT_FdmAmericanStepCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmBermudanStepCondition_t, _p_ext__shared_ptrT_FdmBermudanStepCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSimpleStorageCondition_t, _p_ext__shared_ptrT_FdmSimpleStorageCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmSimpleSwingCondition_t, _p_ext__shared_ptrT_FdmSimpleSwingCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FdmDividendHandler_t, _p_ext__shared_ptrT_FdmDividendHandler_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StochasticProcess1D_t[] = {  {&_swigt__p_ext__shared_ptrT_BlackScholesProcess_t, _p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t, _p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackProcess_t, _p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t, _p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Merton76Process_t, _p_ext__shared_ptrT_Merton76Process_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VarianceGammaProcess_t, _p_ext__shared_ptrT_VarianceGammaProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhiteProcess_t, _p_ext__shared_ptrT_HullWhiteProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhiteForwardProcess_t, _p_ext__shared_ptrT_HullWhiteForwardProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GsrProcess_t, _p_ext__shared_ptrT_GsrProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, _p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, _p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, _p_ext__shared_ptrT_GeneralizedBlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, _p_ext__shared_ptrT_GeometricBrownianMotionProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StochasticProcessArray_t[] = {  {&_swigt__p_ext__shared_ptrT_StochasticProcessArray_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StochasticProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_GsrProcess_t, _p_ext__shared_ptrT_GsrProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2ForwardProcess_t, _p_ext__shared_ptrT_G2ForwardProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_G2Process_t, _p_ext__shared_ptrT_G2Process_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhiteForwardProcess_t, _p_ext__shared_ptrT_HullWhiteForwardProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhiteProcess_t, _p_ext__shared_ptrT_HullWhiteProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BatesProcess_t, _p_ext__shared_ptrT_BatesProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonProcess_t, _p_ext__shared_ptrT_HestonProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VarianceGammaProcess_t, _p_ext__shared_ptrT_VarianceGammaProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Merton76Process_t, _p_ext__shared_ptrT_Merton76Process_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GarmanKohlagenProcess_t, _p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackProcess_t, _p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackScholesMertonProcess_t, _p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackScholesProcess_t, _p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcess_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, _p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, _p_ext__shared_ptrT_ExtOUWithJumpsProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KlugeExtOUProcess_t, _p_ext__shared_ptrT_KlugeExtOUProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GJRGARCHProcess_t, _p_ext__shared_ptrT_GJRGARCHProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonSLVProcess_t, _p_ext__shared_ptrT_HestonSLVProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcess1D_t, _p_ext__shared_ptrT_StochasticProcess1D_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, _p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, _p_ext__shared_ptrT_GeometricBrownianMotionProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, _p_ext__shared_ptrT_GeneralizedBlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StochasticProcessArray_t, _p_ext__shared_ptrT_StochasticProcessArray_tTo_p_ext__shared_ptrT_StochasticProcess_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Stock_t[] = {  {&_swigt__p_ext__shared_ptrT_Stock_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StrikedTypePayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_PlainVanillaPayoff_t, _p_ext__shared_ptrT_PlainVanillaPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PercentageStrikePayoff_t, _p_ext__shared_ptrT_PercentageStrikePayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CashOrNothingPayoff_t, _p_ext__shared_ptrT_CashOrNothingPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AssetOrNothingPayoff_t, _p_ext__shared_ptrT_AssetOrNothingPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SuperSharePayoff_t, _p_ext__shared_ptrT_SuperSharePayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GapPayoff_t, _p_ext__shared_ptrT_GapPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaForwardPayoff_t, _p_ext__shared_ptrT_VanillaForwardPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StrippedOptionletAdapter_t[] = {  {&_swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StrippedOptionletBase_t[] = {  {&_swigt__p_ext__shared_ptrT_StrippedOptionletBase_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_OptionletStripper1_t, _p_ext__shared_ptrT_OptionletStripper1_tTo_p_ext__shared_ptrT_StrippedOptionletBase_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_StulzEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_StulzEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SuperSharePayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_SuperSharePayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwapIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, _p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwapIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, _p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, _p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIfrFix_t, _p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIfrFix_t, _p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, _p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, _p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, _p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_SwapIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwapRateHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_SwapRateHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwapSpreadIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_SwapSpreadIndex_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Swap_t[] = {  {&_swigt__p_ext__shared_ptrT_NonstandardSwap_t, _p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AssetSwap_t, _p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FloatFloatSwap_t, _p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OvernightIndexedSwap_t, _p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwap_t, _p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwap_t, _p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_Swap_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaSwap_t, _p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CPISwap_t, _p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_Swap_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionVolCube1_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionVolCube2_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionVolatilityCube_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, _p_ext__shared_ptrT_SwaptionVolCube1_tTo_p_ext__shared_ptrT_SwaptionVolatilityCube_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, _p_ext__shared_ptrT_SwaptionVolCube2_tTo_p_ext__shared_ptrT_SwaptionVolatilityCube_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, _p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, _p_ext__shared_ptrT_SwaptionVolCube1_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t, _p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, _p_ext__shared_ptrT_SwaptionVolCube2_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwaptionVolatilityStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, _p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, _p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, _p_ext__shared_ptrT_SwaptionVolCube1_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t, _p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t, _p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, _p_ext__shared_ptrT_SwaptionVolCube2_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Swaption_t[] = {  {&_swigt__p_ext__shared_ptrT_Swaption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_SwingExercise_t[] = {  {&_swigt__p_ext__shared_ptrT_SwingExercise_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_THBFIX_t[] = {  {&_swigt__p_ext__shared_ptrT_THBFIX_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TRLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_TRLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TermStructureConsistentModel_t[] = {  {&_swigt__p_ext__shared_ptrT_Gsr_t, _p_ext__shared_ptrT_Gsr_tTo_p_ext__shared_ptrT_TermStructureConsistentModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TermStructureConsistentModel_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_Gaussian1dModel_t, _p_ext__shared_ptrT_Gaussian1dModel_tTo_p_ext__shared_ptrT_TermStructureConsistentModel_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_MarkovFunctional_t, _p_ext__shared_ptrT_MarkovFunctional_tTo_p_ext__shared_ptrT_TermStructureConsistentModel_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, _p_ext__shared_ptrT_SwaptionVolCube2_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, _p_ext__shared_ptrT_SwaptionVolCube1_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t, _p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t, _p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseCubicZero_t, _p_ext__shared_ptrT_PiecewiseCubicZero_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, _p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, _p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatForward_t, _p_ext__shared_ptrT_FlatForward_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatForward_t, _p_ext__shared_ptrT_PiecewiseFlatForward_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearForward_t, _p_ext__shared_ptrT_PiecewiseLinearForward_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t, _p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FittedBondDiscountCurve_t, _p_ext__shared_ptrT_FittedBondDiscountCurve_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, _p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceCurve_t, _p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, _p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackConstantVol_t, _p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalConstantVol_t, _p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t, _p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceSurface_t, _p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolSurface_t, _p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t, _p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t, _p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, _p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t, _p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, _p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, _p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearZero_t, _p_ext__shared_ptrT_PiecewiseLinearZero_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerZero_t, _p_ext__shared_ptrT_PiecewiseKrugerZero_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, _p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, _p_ext__shared_ptrT_YoYOptionletVolatilitySurface_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, _p_ext__shared_ptrT_DefaultProbabilityTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, _p_ext__shared_ptrT_CapFloorTermVolatilityStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, _p_ext__shared_ptrT_PiecewiseFlatHazardRate_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatHazardRate_t, _p_ext__shared_ptrT_FlatHazardRate_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityStructure_t, _p_ext__shared_ptrT_SwaptionVolatilityStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OptionletVolatilityStructure_t, _p_ext__shared_ptrT_OptionletVolatilityStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolTermStructure_t, _p_ext__shared_ptrT_LocalVolTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVolTermStructure_t, _p_ext__shared_ptrT_BlackVolTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VolatilityTermStructure_t, _p_ext__shared_ptrT_VolatilityTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ImpliedTermStructure_t, _p_ext__shared_ptrT_ImpliedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, _p_ext__shared_ptrT_ZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, _p_ext__shared_ptrT_ForwardSpreadedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YieldTermStructure_t, _p_ext__shared_ptrT_YieldTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InflationTermStructure_t, _p_ext__shared_ptrT_InflationTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationTermStructure_t, _p_ext__shared_ptrT_YoYInflationTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationTermStructure_t, _p_ext__shared_ptrT_ZeroInflationTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, _p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, _p_ext__shared_ptrT_PiecewiseLogCubicDiscount_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, _p_ext__shared_ptrT_PiecewiseLogLinearDiscount_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, _p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t, _p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Tibor_t[] = {  {&_swigt__p_ext__shared_ptrT_Tibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TreeCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_TreeCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TreeSwaptionEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_TreeSwaptionEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TripleBandLinearOp_t[] = {  {&_swigt__p_ext__shared_ptrT_FirstDerivativeOp_t, _p_ext__shared_ptrT_FirstDerivativeOp_tTo_p_ext__shared_ptrT_TripleBandLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SecondDerivativeOp_t, _p_ext__shared_ptrT_SecondDerivativeOp_tTo_p_ext__shared_ptrT_TripleBandLinearOp_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_TripleBandLinearOp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_TypePayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_TypePayoff_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_StrikedTypePayoff_t, _p_ext__shared_ptrT_StrikedTypePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PlainVanillaPayoff_t, _p_ext__shared_ptrT_PlainVanillaPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PercentageStrikePayoff_t, _p_ext__shared_ptrT_PercentageStrikePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CashOrNothingPayoff_t, _p_ext__shared_ptrT_CashOrNothingPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AssetOrNothingPayoff_t, _p_ext__shared_ptrT_AssetOrNothingPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SuperSharePayoff_t, _p_ext__shared_ptrT_SuperSharePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GapPayoff_t, _p_ext__shared_ptrT_GapPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VanillaForwardPayoff_t, _p_ext__shared_ptrT_VanillaForwardPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_UKRPI_t[] = {  {&_swigt__p_ext__shared_ptrT_UKRPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_USCPI_t[] = {  {&_swigt__p_ext__shared_ptrT_USCPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_USDLiborON_t[] = {  {&_swigt__p_ext__shared_ptrT_USDLiborON_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_USDLibor_t[] = {  {&_swigt__p_ext__shared_ptrT_USDLibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Uniform1dMesher_t[] = {  {&_swigt__p_ext__shared_ptrT_Uniform1dMesher_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_UpfrontCdsHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_UpfrontCdsHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t[] = {  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t[] = {  {&_swigt__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VanillaForwardPayoff_t[] = {  {&_swigt__p_ext__shared_ptrT_VanillaForwardPayoff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VanillaOption_t[] = {  {&_swigt__p_ext__shared_ptrT_VanillaOption_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_EuropeanOption_t, _p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_VanillaOption_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VanillaSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_VanillaSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VanillaSwingOption_t[] = {  {&_swigt__p_ext__shared_ptrT_VanillaSwingOption_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t[] = {  {&_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t[] = {  {&_swigt__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VarianceGammaEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_VarianceGammaEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VarianceGammaProcess_t[] = {  {&_swigt__p_ext__shared_ptrT_VarianceGammaProcess_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Vasicek_t[] = {  {&_swigt__p_ext__shared_ptrT_Vasicek_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_HullWhite_t, _p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_Vasicek_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_VolatilityTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, _p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_StrippedOptionletAdapter_t, _p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, _p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, _p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, _p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVolTermStructure_t, _p_ext__shared_ptrT_BlackVolTermStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolTermStructure_t, _p_ext__shared_ptrT_LocalVolTermStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_OptionletVolatilityStructure_t, _p_ext__shared_ptrT_OptionletVolatilityStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityStructure_t, _p_ext__shared_ptrT_SwaptionVolatilityStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube1_t, _p_ext__shared_ptrT_SwaptionVolCube1_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, _p_ext__shared_ptrT_YoYOptionletVolatilitySurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolatilityCube_t, _p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, _p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_SwaptionVolCube2_t, _p_ext__shared_ptrT_SwaptionVolCube2_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_HestonBlackVolSurface_t, _p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceSurface_t, _p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalVolSurface_t, _p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_NoExceptLocalVolSurface_t, _p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolSurface_t, _p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackVarianceCurve_t, _p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, _p_ext__shared_ptrT_CapFloorTermVolatilityStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_CapFloorTermVolCurve_t, _p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantOptionletVolatility_t, _p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantSwaptionVolatility_t, _p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_BlackConstantVol_t, _p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_LocalConstantVol_t, _p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, _p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Wibor_t[] = {  {&_swigt__p_ext__shared_ptrT_Wibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYEUHICPXT_t[] = {  {&_swigt__p_ext__shared_ptrT_YYEUHICPXT_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYEUHICP_t[] = {  {&_swigt__p_ext__shared_ptrT_YYEUHICP_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYEUHICPr_t[] = {  {&_swigt__p_ext__shared_ptrT_YYEUHICPr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYFRHICP_t[] = {  {&_swigt__p_ext__shared_ptrT_YYFRHICP_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYFRHICPr_t[] = {  {&_swigt__p_ext__shared_ptrT_YYFRHICPr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYUKRPI_t[] = {  {&_swigt__p_ext__shared_ptrT_YYUKRPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYUKRPIr_t[] = {  {&_swigt__p_ext__shared_ptrT_YYUKRPIr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYUSCPI_t[] = {  {&_swigt__p_ext__shared_ptrT_YYUSCPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYUSCPIr_t[] = {  {&_swigt__p_ext__shared_ptrT_YYUSCPIr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYZACPI_t[] = {  {&_swigt__p_ext__shared_ptrT_YYZACPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YYZACPIr_t[] = {  {&_swigt__p_ext__shared_ptrT_YYZACPIr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YearOnYearInflationSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YieldTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseCubicZero_t, _p_ext__shared_ptrT_PiecewiseCubicZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, _p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, _p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, _p_ext__shared_ptrT_PiecewiseLogCubicDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, _p_ext__shared_ptrT_PiecewiseLogLinearDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, _p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, _p_ext__shared_ptrT_ZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, _p_ext__shared_ptrT_ForwardSpreadedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YieldTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseKrugerZero_t, _p_ext__shared_ptrT_PiecewiseKrugerZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearZero_t, _p_ext__shared_ptrT_PiecewiseLinearZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ImpliedTermStructure_t, _p_ext__shared_ptrT_ImpliedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseLinearForward_t, _p_ext__shared_ptrT_PiecewiseLinearForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseFlatForward_t, _p_ext__shared_ptrT_PiecewiseFlatForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FlatForward_t, _p_ext__shared_ptrT_FlatForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, _p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, _p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FittedBondDiscountCurve_t, _p_ext__shared_ptrT_FittedBondDiscountCurve_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, _p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, _p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationCapFloor_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationCap_t, _p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCapFloor_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationFloor_t, _p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationCollar_t, _p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationCap_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationCap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationCollar_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationCollar_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationFloor_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationFloor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_YYUSCPI_t, _p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPXT_t, _p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICP_t, _p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPI_t, _p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICP_t, _p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUSCPIr_t, _p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPIr_t, _p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYEUHICPr_t, _p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYFRHICPr_t, _p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYZACPI_t, _p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YYUKRPIr_t, _p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYInflationTermStructure_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYOptionletHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_YoYOptionletHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYOptionletStripper_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_tTo_p_ext__shared_ptrT_YoYOptionletStripper_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletStripper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t[] = {  {&_swigt__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, _p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, _p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZACPI_t[] = {  {&_swigt__p_ext__shared_ptrT_ZACPI_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t[] = {  {&_swigt__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZeroCouponBond_t[] = {  {&_swigt__p_ext__shared_ptrT_ZeroCouponBond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t[] = {  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZeroCouponInflationSwap_t[] = {  {&_swigt__p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZeroInflationIndex_t[] = {  {&_swigt__p_ext__shared_ptrT_USCPI_t, _p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICPXT_t, _p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_FRHICP_t, _p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_UKRPI_t, _p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_EUHICP_t, _p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_AUCPI_t, _p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZACPI_t, _p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZeroInflationTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, _p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0, 0},  {&_swigt__p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t[] = {  {&_swigt__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__shared_ptrT_Zibor_t[] = {  {&_swigt__p_ext__shared_ptrT_Zibor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__tupleT_double_double_bool_t[] = {  {&_swigt__p_ext__tupleT_double_double_bool_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ext__tupleT_double_double_double_t[] = {  {&_swigt__p_ext__tupleT_double_double_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_first_type[] = {  {&_swigt__p_first_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sample_type[] = {  {&_swigt__p_sample_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_second_type[] = {  {&_swigt__p_second_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Date_t[] = {  {&_swigt__p_std__allocatorT_Date_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_HandleT_Quote_t_t[] = {  {&_swigt__p_std__allocatorT_HandleT_Quote_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_InterestRate_t[] = {  {&_swigt__p_std__allocatorT_InterestRate_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_IntervalPrice_t[] = {  {&_swigt__p_std__allocatorT_IntervalPrice_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Period_t[] = {  {&_swigt__p_std__allocatorT_Period_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_RelinkableHandleT_Quote_t_t[] = {  {&_swigt__p_std__allocatorT_RelinkableHandleT_Quote_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_bool_t[] = {  {&_swigt__p_std__allocatorT_bool_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_double_t[] = {  {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_Callability_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_Callability_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_Dividend_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_Dividend_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_Instrument_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_Instrument_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_Quote_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_Quote_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t[] = {  {&_swigt__p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t[] = {  {&_swigt__p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_int_t[] = {  {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_Date_double_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_Date_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_double_const_Date_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_double_const_Date_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_double_double_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_double_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_int_t[] = {  {&_swigt__p_std__allocatorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_double_t[] = {  {&_swigt__p_std__lessT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t[] = {  {&_swigt__p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_Date_double_t[] = {  {&_swigt__p_std__pairT_Date_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_double_double_t[] = {  {&_swigt__p_std__pairT_double_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t[] = {  {&_swigt__p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_size_t_size_t_t[] = {  {&_swigt__p_std__pairT_size_t_size_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t[] = {  {&_swigt__p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t[] = {  {&_swigt__p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Date_std__allocatorT_Date_t_t[] = {  {&_swigt__p_std__vectorT_Date_std__allocatorT_Date_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t[] = {  {&_swigt__p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t[] = {  {&_swigt__p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t[] = {  {&_swigt__p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Period_std__allocatorT_Period_t_t[] = {  {&_swigt__p_std__vectorT_Period_std__allocatorT_Period_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t[] = {  {&_swigt__p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t[] = {  {&_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t[] = {  {&_swigt__p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__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[] = {  {&_swigt__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, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_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[] = {  {&_swigt__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, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__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[] = {  {&_swigt__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, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_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[] = {  {&_swigt__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, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t[] = {  {&_swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ASX,
  _swigc__p_AUCPI,
  _swigc__p_AUDLibor,
  _swigc__p_AdaptiveRungeKuttaT_double_t,
  _swigc__p_AmericanExercise,
  _swigc__p_AmortizingFixedRateBond,
  _swigc__p_AmortizingFloatingRateBond,
  _swigc__p_AmortizingPayment,
  _swigc__p_AnalyticBSMHullWhiteEngine,
  _swigc__p_AnalyticBarrierEngine,
  _swigc__p_AnalyticBinaryBarrierEngine,
  _swigc__p_AnalyticCEVEngine,
  _swigc__p_AnalyticCapFloorEngine,
  _swigc__p_AnalyticContinuousGeometricAveragePriceAsianEngine,
  _swigc__p_AnalyticDigitalAmericanEngine,
  _swigc__p_AnalyticDigitalAmericanKOEngine,
  _swigc__p_AnalyticDiscreteGeometricAveragePriceAsianEngine,
  _swigc__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine,
  _swigc__p_AnalyticDividendEuropeanEngine,
  _swigc__p_AnalyticDoubleBarrierBinaryEngine,
  _swigc__p_AnalyticDoubleBarrierEngine,
  _swigc__p_AnalyticEuropeanEngine,
  _swigc__p_AnalyticGJRGARCHEngine,
  _swigc__p_AnalyticHaganPricer,
  _swigc__p_AnalyticHestonEngine,
  _swigc__p_AnalyticHestonEngine__Integration,
  _swigc__p_AnalyticPTDHestonEngine,
  _swigc__p_AndreasenHugeLocalVolAdapter,
  _swigc__p_AndreasenHugeVolatilityAdapter,
  _swigc__p_AndreasenHugeVolatilityInterpl,
  _swigc__p_Aonia,
  _swigc__p_Array,
  _swigc__p_AssetOrNothingPayoff,
  _swigc__p_AssetSwap,
  _swigc__p_Average,
  _swigc__p_AverageBasketPayoff,
  _swigc__p_BFGS,
  _swigc__p_BSMRNDCalculator,
  _swigc__p_BachelierCapFloorEngine,
  _swigc__p_BachelierSwaptionEngine,
  _swigc__p_BackwardFlat,
  _swigc__p_BaroneAdesiWhaleyApproximationEngine,
  _swigc__p_Barrier,
  _swigc__p_BarrierOption,
  _swigc__p_BasketOption,
  _swigc__p_BasketPayoff,
  _swigc__p_BatesEngine,
  _swigc__p_BatesModel,
  _swigc__p_BatesProcess,
  _swigc__p_Bbsw,
  _swigc__p_Bbsw1M,
  _swigc__p_Bbsw2M,
  _swigc__p_Bbsw3M,
  _swigc__p_Bbsw4M,
  _swigc__p_Bbsw5M,
  _swigc__p_Bbsw6M,
  _swigc__p_BermudanExercise,
  _swigc__p_BiCGstab,
  _swigc__p_Bibor,
  _swigc__p_Bibor1M,
  _swigc__p_Bibor1Y,
  _swigc__p_Bibor2M,
  _swigc__p_Bibor3M,
  _swigc__p_Bibor6M,
  _swigc__p_Bibor9M,
  _swigc__p_BiborSW,
  _swigc__p_Bicubic,
  _swigc__p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t,
  _swigc__p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t,
  _swigc__p_BinomialConvertibleEngineT_CoxRossRubinstein_t,
  _swigc__p_BinomialConvertibleEngineT_JarrowRudd_t,
  _swigc__p_BinomialConvertibleEngineT_Joshi4_t,
  _swigc__p_BinomialConvertibleEngineT_LeisenReimer_t,
  _swigc__p_BinomialConvertibleEngineT_Tian_t,
  _swigc__p_BinomialConvertibleEngineT_Trigeorgis_t,
  _swigc__p_BinomialDistribution,
  _swigc__p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t,
  _swigc__p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t,
  _swigc__p_BinomialVanillaEngineT_CoxRossRubinstein_t,
  _swigc__p_BinomialVanillaEngineT_JarrowRudd_t,
  _swigc__p_BinomialVanillaEngineT_Joshi4_t,
  _swigc__p_BinomialVanillaEngineT_LeisenReimer_t,
  _swigc__p_BinomialVanillaEngineT_Tian_t,
  _swigc__p_BinomialVanillaEngineT_Trigeorgis_t,
  _swigc__p_Bisection,
  _swigc__p_BivariateCumulativeNormalDistribution,
  _swigc__p_BivariateCumulativeNormalDistributionDr78,
  _swigc__p_BivariateCumulativeNormalDistributionWe04DP,
  _swigc__p_BjerksundStenslandApproximationEngine,
  _swigc__p_Bkbm,
  _swigc__p_Bkbm1M,
  _swigc__p_Bkbm2M,
  _swigc__p_Bkbm3M,
  _swigc__p_Bkbm4M,
  _swigc__p_Bkbm5M,
  _swigc__p_Bkbm6M,
  _swigc__p_BlackCalculator,
  _swigc__p_BlackCalibrationHelper,
  _swigc__p_BlackCallableFixedRateBondEngine,
  _swigc__p_BlackCapFloorEngine,
  _swigc__p_BlackCdsOptionEngine,
  _swigc__p_BlackConstantVol,
  _swigc__p_BlackDeltaCalculator,
  _swigc__p_BlackIborCouponPricer,
  _swigc__p_BlackKarasinski,
  _swigc__p_BlackProcess,
  _swigc__p_BlackScholesMertonProcess,
  _swigc__p_BlackScholesProcess,
  _swigc__p_BlackSwaptionEngine,
  _swigc__p_BlackVarianceCurve,
  _swigc__p_BlackVarianceSurface,
  _swigc__p_BlackVolTermStructure,
  _swigc__p_Bond,
  _swigc__p_BondFunctions,
  _swigc__p_BondHelper,
  _swigc__p_BootstrapHelperT_YoYInflationTermStructure_t,
  _swigc__p_BootstrapHelperT_YoYOptionletVolatilitySurface_t,
  _swigc__p_BootstrapHelperT_ZeroInflationTermStructure_t,
  _swigc__p_BoundaryConstraint,
  _swigc__p_BoxMullerGaussianRngT_KnuthUniformRng_t,
  _swigc__p_BoxMullerGaussianRngT_LecuyerUniformRng_t,
  _swigc__p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t,
  _swigc__p_Brent,
  _swigc__p_BrownianBridge,
  _swigc__p_BrownianGeneratorFactory,
  _swigc__p_CADLibor,
  _swigc__p_CADLiborON,
  _swigc__p_CEVRNDCalculator,
  _swigc__p_CHFLibor,
  _swigc__p_CLGaussianRngT_KnuthUniformRng_t,
  _swigc__p_CLGaussianRngT_LecuyerUniformRng_t,
  _swigc__p_CLGaussianRngT_MersenneTwisterUniformRng_t,
  _swigc__p_COSHestonEngine,
  _swigc__p_CPI,
  _swigc__p_CPIBond,
  _swigc__p_CPICoupon,
  _swigc__p_CPISwap,
  _swigc__p_Calendar,
  _swigc__p_CalibratedModel,
  _swigc__p_CalibrationHelper,
  _swigc__p_CalibrationSet,
  _swigc__p_Callability,
  _swigc__p_CallabilityPrice,
  _swigc__p_CallableBond,
  _swigc__p_CallableFixedRateBond,
  _swigc__p_CallableZeroCouponBond,
  _swigc__p_Cap,
  _swigc__p_CapFloor,
  _swigc__p_CapFloorTermVolCurve,
  _swigc__p_CapFloorTermVolSurface,
  _swigc__p_CapFloorTermVolatilityStructure,
  _swigc__p_CapHelper,
  _swigc__p_CappedFlooredCmsCoupon,
  _swigc__p_CappedFlooredCmsSpreadCoupon,
  _swigc__p_CappedFlooredCoupon,
  _swigc__p_CappedFlooredIborCoupon,
  _swigc__p_CashFlow,
  _swigc__p_CashFlows,
  _swigc__p_CashOrNothingPayoff,
  _swigc__p_Cdor,
  _swigc__p_CdsOption,
  _swigc__p_CeilingTruncation,
  _swigc__p_ChfLiborSwapIsdaFix,
  _swigc__p_Claim,
  _swigc__p_ClosestRounding,
  _swigc__p_CmsCoupon,
  _swigc__p_CmsCouponPricer,
  _swigc__p_CmsMarket,
  _swigc__p_CmsMarketCalibration,
  _swigc__p_CmsRateBond,
  _swigc__p_CmsSpreadCoupon,
  _swigc__p_CmsSpreadCouponPricer,
  _swigc__p_Collar,
  _swigc__p_CompositeConstraint,
  _swigc__p_CompositeInstrument,
  _swigc__p_CompositeQuoteT_BinaryFunction_t,
  _swigc__p_Concentrating1dMesher,
  _swigc__p_Conditions,
  _swigc__p_ConjugateGradient,
  _swigc__p_ConstantEstimator,
  _swigc__p_ConstantOptionletVolatility,
  _swigc__p_ConstantParameter,
  _swigc__p_ConstantSwaptionVolatility,
  _swigc__p_ConstantYoYOptionletVolatility,
  _swigc__p_Constraint,
  _swigc__p_ContinuousArithmeticAsianLevyEngine,
  _swigc__p_ContinuousAveragingAsianOption,
  _swigc__p_ConvertibleFixedCouponBond,
  _swigc__p_ConvertibleFloatingRateBond,
  _swigc__p_ConvertibleZeroCouponBond,
  _swigc__p_ConvexMonotone,
  _swigc__p_Coupon,
  _swigc__p_CoxIngersollRoss,
  _swigc__p_CraigSneydScheme,
  _swigc__p_CrankNicolsonScheme,
  _swigc__p_CreditDefaultSwap,
  _swigc__p_Cubic,
  _swigc__p_CubicBSplinesFitting,
  _swigc__p_CumulativeBinomialDistribution,
  _swigc__p_CumulativeChiSquareDistribution,
  _swigc__p_CumulativeGammaDistribution,
  _swigc__p_CumulativeNormalDistribution,
  _swigc__p_CumulativePoissonDistribution,
  _swigc__p_CumulativeStudentDistribution,
  _swigc__p_Currency,
  _swigc__p_CustomRegion,
  _swigc__p_DKKLibor,
  _swigc__p_DMinus,
  _swigc__p_DPlus,
  _swigc__p_DPlusDMinus,
  _swigc__p_DZero,
  _swigc__p_DailyTenorLibor,
  _swigc__p_Date,
  _swigc__p_DateGeneration,
  _swigc__p_DateParser,
  _swigc__p_DatedOISRateHelper,
  _swigc__p_DayCounter,
  _swigc__p_DefaultBoundaryCondition,
  _swigc__p_DefaultDensity,
  _swigc__p_DefaultLexicographicalView,
  _swigc__p_DefaultLexicographicalViewColumn,
  _swigc__p_DefaultLogCubic,
  _swigc__p_DefaultProbabilityHelper,
  _swigc__p_DefaultProbabilityTermStructure,
  _swigc__p_DeltaVolQuote,
  _swigc__p_DepositRateHelper,
  _swigc__p_DerivedQuoteT_UnaryFunction_t,
  _swigc__p_DifferentialEvolution,
  _swigc__p_DirichletBC,
  _swigc__p_Discount,
  _swigc__p_DiscountingBondEngine,
  _swigc__p_DiscountingSwapEngine,
  _swigc__p_DiscreteAveragingAsianOption,
  _swigc__p_DisposableT_Array_t,
  _swigc__p_Dividend,
  _swigc__p_DividendBarrierOption,
  _swigc__p_DividendVanillaOption,
  _swigc__p_DoubleBarrier,
  _swigc__p_DoubleBarrierOption,
  _swigc__p_DouglasScheme,
  _swigc__p_DownRounding,
  _swigc__p_Duration,
  _swigc__p_EUHICP,
  _swigc__p_EUHICPXT,
  _swigc__p_EURLibor,
  _swigc__p_EURLibor10M,
  _swigc__p_EURLibor11M,
  _swigc__p_EURLibor1M,
  _swigc__p_EURLibor1Y,
  _swigc__p_EURLibor2M,
  _swigc__p_EURLibor2W,
  _swigc__p_EURLibor3M,
  _swigc__p_EURLibor4M,
  _swigc__p_EURLibor5M,
  _swigc__p_EURLibor6M,
  _swigc__p_EURLibor7M,
  _swigc__p_EURLibor8M,
  _swigc__p_EURLibor9M,
  _swigc__p_EURLiborSW,
  _swigc__p_EndCriteria,
  _swigc__p_EndCriteria__Type,
  _swigc__p_Eonia,
  _swigc__p_EurLiborSwapIfrFix,
  _swigc__p_EurLiborSwapIsdaFixA,
  _swigc__p_EurLiborSwapIsdaFixB,
  _swigc__p_Euribor,
  _swigc__p_Euribor10M,
  _swigc__p_Euribor11M,
  _swigc__p_Euribor1M,
  _swigc__p_Euribor1Y,
  _swigc__p_Euribor2M,
  _swigc__p_Euribor2W,
  _swigc__p_Euribor365,
  _swigc__p_Euribor365_10M,
  _swigc__p_Euribor365_11M,
  _swigc__p_Euribor365_1M,
  _swigc__p_Euribor365_1Y,
  _swigc__p_Euribor365_2M,
  _swigc__p_Euribor365_2W,
  _swigc__p_Euribor365_3M,
  _swigc__p_Euribor365_3W,
  _swigc__p_Euribor365_4M,
  _swigc__p_Euribor365_5M,
  _swigc__p_Euribor365_6M,
  _swigc__p_Euribor365_7M,
  _swigc__p_Euribor365_8M,
  _swigc__p_Euribor365_9M,
  _swigc__p_Euribor365_SW,
  _swigc__p_Euribor3M,
  _swigc__p_Euribor3W,
  _swigc__p_Euribor4M,
  _swigc__p_Euribor5M,
  _swigc__p_Euribor6M,
  _swigc__p_Euribor7M,
  _swigc__p_Euribor8M,
  _swigc__p_Euribor9M,
  _swigc__p_EuriborSW,
  _swigc__p_EuriborSwapIfrFix,
  _swigc__p_EuriborSwapIsdaFixA,
  _swigc__p_EuriborSwapIsdaFixB,
  _swigc__p_EuropeanExercise,
  _swigc__p_EuropeanOption,
  _swigc__p_EverestOption,
  _swigc__p_ExchangeRate,
  _swigc__p_ExchangeRateManager,
  _swigc__p_Exercise,
  _swigc__p_ExplicitEulerScheme,
  _swigc__p_ExponentialFittingHestonEngine,
  _swigc__p_ExponentialJump1dMesher,
  _swigc__p_ExponentialSplinesFitting,
  _swigc__p_ExtOUWithJumpsProcess,
  _swigc__p_ExtendedCoxIngersollRoss,
  _swigc__p_ExtendedOrnsteinUhlenbeckProcess,
  _swigc__p_FDAmericanEngineT_CrankNicolson_t,
  _swigc__p_FDBermudanEngineT_CrankNicolson_t,
  _swigc__p_FDDividendAmericanEngineT_CrankNicolson_t,
  _swigc__p_FDDividendEuropeanEngineT_CrankNicolson_t,
  _swigc__p_FDEuropeanEngineT_CrankNicolson_t,
  _swigc__p_FDShoutEngineT_CrankNicolson_t,
  _swigc__p_FFTVarianceGammaEngine,
  _swigc__p_FRHICP,
  _swigc__p_FaceValueAccrualClaim,
  _swigc__p_FaceValueClaim,
  _swigc__p_FalsePosition,
  _swigc__p_Fd2dBlackScholesVanillaEngine,
  _swigc__p_FdBatesVanillaEngine,
  _swigc__p_FdBlackScholesAsianEngine,
  _swigc__p_FdBlackScholesBarrierEngine,
  _swigc__p_FdBlackScholesRebateEngine,
  _swigc__p_FdBlackScholesVanillaEngine,
  _swigc__p_FdCEVVanillaEngine,
  _swigc__p_FdG2SwaptionEngine,
  _swigc__p_FdHestonBarrierEngine,
  _swigc__p_FdHestonDoubleBarrierEngine,
  _swigc__p_FdHestonRebateEngine,
  _swigc__p_FdHestonVanillaEngine,
  _swigc__p_FdHullWhiteSwaptionEngine,
  _swigc__p_FdOrnsteinUhlenbeckVanillaEngine,
  _swigc__p_FdSabrVanillaEngine,
  _swigc__p_FdSimpleBSSwingEngine,
  _swigc__p_FdSimpleExtOUJumpSwingEngine,
  _swigc__p_Fdm1DimSolver,
  _swigc__p_Fdm1dMesher,
  _swigc__p_Fdm2DimSolver,
  _swigc__p_Fdm2dBlackScholesOp,
  _swigc__p_Fdm2dBlackScholesSolver,
  _swigc__p_Fdm3DimSolver,
  _swigc__p_FdmAffineModelSwapInnerValueT_G2_t,
  _swigc__p_FdmAffineModelSwapInnerValueT_HullWhite_t,
  _swigc__p_FdmAmericanStepCondition,
  _swigc__p_FdmArithmeticAverageCondition,
  _swigc__p_FdmBackwardSolver,
  _swigc__p_FdmBatesOp,
  _swigc__p_FdmBermudanStepCondition,
  _swigc__p_FdmBlackScholesFwdOp,
  _swigc__p_FdmBlackScholesMesher,
  _swigc__p_FdmBlackScholesOp,
  _swigc__p_FdmBoundaryCondition,
  _swigc__p_FdmCEV1dMesher,
  _swigc__p_FdmCEVOp,
  _swigc__p_FdmCellAveragingInnerValue,
  _swigc__p_FdmDirichletBoundary,
  _swigc__p_FdmDiscountDirichletBoundary,
  _swigc__p_FdmDividendHandler,
  _swigc__p_FdmDupire1dOp,
  _swigc__p_FdmG2Op,
  _swigc__p_FdmG2Solver,
  _swigc__p_FdmHestonFwdOp,
  _swigc__p_FdmHestonGreensFct,
  _swigc__p_FdmHestonHullWhiteOp,
  _swigc__p_FdmHestonHullWhiteSolver,
  _swigc__p_FdmHestonLocalVolatilityVarianceMesher,
  _swigc__p_FdmHestonOp,
  _swigc__p_FdmHestonSolver,
  _swigc__p_FdmHestonVarianceMesher,
  _swigc__p_FdmHullWhiteOp,
  _swigc__p_FdmHullWhiteSolver,
  _swigc__p_FdmIndicesOnBoundary,
  _swigc__p_FdmInnerValueCalculator,
  _swigc__p_FdmInnerValueCalculatorProxy,
  _swigc__p_FdmLinearOp,
  _swigc__p_FdmLinearOpComposite,
  _swigc__p_FdmLinearOpCompositeProxy,
  _swigc__p_FdmLinearOpIterator,
  _swigc__p_FdmLinearOpLayout,
  _swigc__p_FdmLocalVolFwdOp,
  _swigc__p_FdmLogBasketInnerValue,
  _swigc__p_FdmLogInnerValue,
  _swigc__p_FdmMesher,
  _swigc__p_FdmMesherComposite,
  _swigc__p_FdmNdimSolverT_4_t,
  _swigc__p_FdmNdimSolverT_5_t,
  _swigc__p_FdmNdimSolverT_6_t,
  _swigc__p_FdmOrnsteinUhlenbeckOp,
  _swigc__p_FdmQuantoHelper,
  _swigc__p_FdmSabrOp,
  _swigc__p_FdmSchemeDesc,
  _swigc__p_FdmSimpleProcess1dMesher,
  _swigc__p_FdmSimpleStorageCondition,
  _swigc__p_FdmSimpleSwingCondition,
  _swigc__p_FdmSnapshotCondition,
  _swigc__p_FdmSolverDesc,
  _swigc__p_FdmSquareRootFwdOp,
  _swigc__p_FdmStepConditionComposite,
  _swigc__p_FdmStepConditionProxy,
  _swigc__p_FdmTimeDepDirichletBoundary,
  _swigc__p_FdmZabrOp,
  _swigc__p_FdmZeroInnerValue,
  _swigc__p_FedFunds,
  _swigc__p_FirstDerivativeOp,
  _swigc__p_FittedBondDiscountCurve,
  _swigc__p_FittingMethod,
  _swigc__p_FixedDividend,
  _swigc__p_FixedRateBond,
  _swigc__p_FixedRateBondForward,
  _swigc__p_FixedRateBondHelper,
  _swigc__p_FixedRateCoupon,
  _swigc__p_FlatForward,
  _swigc__p_FlatHazardRate,
  _swigc__p_FlatSmileSection,
  _swigc__p_FloatFloatSwap,
  _swigc__p_FloatFloatSwaption,
  _swigc__p_FloatingRateBond,
  _swigc__p_FloatingRateCoupon,
  _swigc__p_FloatingRateCouponPricer,
  _swigc__p_Floor,
  _swigc__p_FloorTruncation,
  _swigc__p_Forward,
  _swigc__p_ForwardEuropeanEngine,
  _swigc__p_ForwardFlat,
  _swigc__p_ForwardRate,
  _swigc__p_ForwardRateAgreement,
  _swigc__p_ForwardSpreadedTermStructure,
  _swigc__p_ForwardVanillaOption,
  _swigc__p_FraRateHelper,
  _swigc__p_FractionalDividend,
  _swigc__p_Futures,
  _swigc__p_FuturesRateHelper,
  _swigc__p_FxSwapRateHelper,
  _swigc__p_G2,
  _swigc__p_G2ForwardProcess,
  _swigc__p_G2Process,
  _swigc__p_G2SwaptionEngine,
  _swigc__p_GBPLibor,
  _swigc__p_GBPLiborON,
  _swigc__p_GBSMRNDCalculator,
  _swigc__p_GFunctionFactory,
  _swigc__p_GJRGARCHModel,
  _swigc__p_GJRGARCHProcess,
  _swigc__p_GMRES,
  _swigc__p_GammaFunction,
  _swigc__p_GapPayoff,
  _swigc__p_GarmanKlassSigma1,
  _swigc__p_GarmanKlassSigma3,
  _swigc__p_GarmanKlassSigma4,
  _swigc__p_GarmanKlassSigma5,
  _swigc__p_GarmanKlassSigma6,
  _swigc__p_GarmanKohlagenProcess,
  _swigc__p_GaussChebyshev2ndIntegration,
  _swigc__p_GaussChebyshevIntegration,
  _swigc__p_GaussGegenbauerIntegration,
  _swigc__p_GaussHermiteIntegration,
  _swigc__p_GaussHyperbolicIntegration,
  _swigc__p_GaussJacobiIntegration,
  _swigc__p_GaussKronrodAdaptive,
  _swigc__p_GaussKronrodNonAdaptive,
  _swigc__p_GaussLaguerreIntegration,
  _swigc__p_GaussLegendreIntegration,
  _swigc__p_GaussLobattoIntegral,
  _swigc__p_Gaussian1dFloatFloatSwaptionEngine,
  _swigc__p_Gaussian1dJamshidianSwaptionEngine,
  _swigc__p_Gaussian1dModel,
  _swigc__p_Gaussian1dNonstandardSwaptionEngine,
  _swigc__p_Gaussian1dSwaptionEngine,
  _swigc__p_GaussianLowDiscrepancySequenceGenerator,
  _swigc__p_GaussianMultiPathGenerator,
  _swigc__p_GaussianRandomGenerator,
  _swigc__p_GaussianRandomSequenceGenerator,
  _swigc__p_GaussianSimulatedAnnealing,
  _swigc__p_GbpLiborSwapIsdaFix,
  _swigc__p_GeneralizedBlackScholesProcess,
  _swigc__p_GenericSequenceStatisticsT_IncrementalStatistics_t,
  _swigc__p_GenericSequenceStatisticsT_RiskStatistics_t,
  _swigc__p_GenericSequenceStatisticsT_Statistics_t,
  _swigc__p_GeometricBrownianMotionProcess,
  _swigc__p_GlobalLinearSimpleZeroCurve,
  _swigc__p_Glued1dMesher,
  _swigc__p_Gsr,
  _swigc__p_GsrProcess,
  _swigc__p_HaltonRsg,
  _swigc__p_HandleT_BlackVolTermStructure_t,
  _swigc__p_HandleT_CalibratedModel_t,
  _swigc__p_HandleT_CapFloorTermVolatilityStructure_t,
  _swigc__p_HandleT_DefaultProbabilityTermStructure_t,
  _swigc__p_HandleT_DeltaVolQuote_t,
  _swigc__p_HandleT_HestonModel_t,
  _swigc__p_HandleT_LocalVolTermStructure_t,
  _swigc__p_HandleT_OptionletVolatilityStructure_t,
  _swigc__p_HandleT_Quote_t,
  _swigc__p_HandleT_ShortRateModel_t,
  _swigc__p_HandleT_SwaptionVolatilityStructure_t,
  _swigc__p_HandleT_YieldTermStructure_t,
  _swigc__p_HandleT_YoYInflationTermStructure_t,
  _swigc__p_HandleT_YoYOptionletVolatilitySurface_t,
  _swigc__p_HandleT_ZeroInflationTermStructure_t,
  _swigc__p_HazardRate,
  _swigc__p_HestonBlackVolSurface,
  _swigc__p_HestonModel,
  _swigc__p_HestonModelHelper,
  _swigc__p_HestonProcess,
  _swigc__p_HestonRNDCalculator,
  _swigc__p_HestonSLVFDMModel,
  _swigc__p_HestonSLVFokkerPlanckFdmParams,
  _swigc__p_HestonSLVMCModel,
  _swigc__p_HestonSLVProcess,
  _swigc__p_HimalayaOption,
  _swigc__p_HullWhite,
  _swigc__p_HullWhiteForwardProcess,
  _swigc__p_HullWhiteProcess,
  _swigc__p_HundsdorferScheme,
  _swigc__p_IMM,
  _swigc__p_IborCoupon,
  _swigc__p_IborCouponPricer,
  _swigc__p_IborIndex,
  _swigc__p_ImplicitEulerScheme,
  _swigc__p_ImpliedTermStructure,
  _swigc__p_IncrementalStatistics,
  _swigc__p_Index,
  _swigc__p_IndexManager,
  _swigc__p_IndexedCashFlow,
  _swigc__p_InflationCoupon,
  _swigc__p_InflationIndex,
  _swigc__p_InflationTermStructure,
  _swigc__p_Instrument,
  _swigc__p_IntegralCdsEngine,
  _swigc__p_IntegralEngine,
  _swigc__p_Integration,
  _swigc__p_InterestRate,
  _swigc__p_InterestRateIndex,
  _swigc__p_InterpolatedDefaultDensityCurveT_Linear_t,
  _swigc__p_InterpolatedDiscountCurveT_LogLinear_t,
  _swigc__p_InterpolatedDiscountCurveT_MonotonicLogCubic_t,
  _swigc__p_InterpolatedDiscountCurveT_SplineCubic_t,
  _swigc__p_InterpolatedForwardCurveT_BackwardFlat_t,
  _swigc__p_InterpolatedHazardRateCurveT_BackwardFlat_t,
  _swigc__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t,
  _swigc__p_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t,
  _swigc__p_InterpolatedSmileSectionT_Cubic_t,
  _swigc__p_InterpolatedSmileSectionT_Linear_t,
  _swigc__p_InterpolatedSmileSectionT_MonotonicCubic_t,
  _swigc__p_InterpolatedSmileSectionT_SplineCubic_t,
  _swigc__p_InterpolatedSurvivalProbabilityCurveT_Linear_t,
  _swigc__p_InterpolatedYoYInflationCurveT_Linear_t,
  _swigc__p_InterpolatedYoYOptionletStripperT_Linear_t,
  _swigc__p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t,
  _swigc__p_InterpolatedZeroCurveT_Cubic_t,
  _swigc__p_InterpolatedZeroCurveT_DefaultLogCubic_t,
  _swigc__p_InterpolatedZeroCurveT_Linear_t,
  _swigc__p_InterpolatedZeroCurveT_LogLinear_t,
  _swigc__p_InterpolatedZeroCurveT_MonotonicCubic_t,
  _swigc__p_InterpolatedZeroCurveT_SplineCubic_t,
  _swigc__p_InterpolatedZeroInflationCurveT_Linear_t,
  _swigc__p_IntervalPrice,
  _swigc__p_InverseCumulativeNormal,
  _swigc__p_InverseCumulativePoisson,
  _swigc__p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t,
  _swigc__p_InverseCumulativeStudent,
  _swigc__p_InverseNonCentralCumulativeChiSquareDistribution,
  _swigc__p_IsdaCdsEngine,
  _swigc__p_JPYLibor,
  _swigc__p_JamshidianSwaptionEngine,
  _swigc__p_Jibar,
  _swigc__p_JpyLiborSwapIsdaFixAm,
  _swigc__p_JpyLiborSwapIsdaFixPm,
  _swigc__p_JuQuadraticApproximationEngine,
  _swigc__p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t,
  _swigc__p_KahaleSmileSection,
  _swigc__p_KerkhofSeasonality,
  _swigc__p_KirkEngine,
  _swigc__p_KirkSpreadOptionEngine,
  _swigc__p_KlugeExtOUProcess,
  _swigc__p_KnuthUniformRng,
  _swigc__p_Kruger,
  _swigc__p_KrugerLog,
  _swigc__p_LecuyerUniformRng,
  _swigc__p_LevenbergMarquardt,
  _swigc__p_Libor,
  _swigc__p_Linear,
  _swigc__p_LinearTsrPricer,
  _swigc__p_LinearTsrPricer__Settings,
  _swigc__p_LocalConstantVol,
  _swigc__p_LocalVolRNDCalculator,
  _swigc__p_LocalVolSurface,
  _swigc__p_LocalVolTermStructure,
  _swigc__p_LogLinear,
  _swigc__p_LogNormalSimulatedAnnealing,
  _swigc__p_LognormalCmsSpreadPricer,
  _swigc__p_LsmBasisSystem,
  _swigc__p_MCAmericanBasketEngineT_LowDiscrepancy_t,
  _swigc__p_MCAmericanBasketEngineT_PseudoRandom_t,
  _swigc__p_MCAmericanEngineT_LowDiscrepancy_t,
  _swigc__p_MCAmericanEngineT_PseudoRandom_t,
  _swigc__p_MCBarrierEngineT_LowDiscrepancy_t,
  _swigc__p_MCBarrierEngineT_PseudoRandom_t,
  _swigc__p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t,
  _swigc__p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t,
  _swigc__p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t,
  _swigc__p_MCDiscreteArithmeticASEngineT_PseudoRandom_t,
  _swigc__p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t,
  _swigc__p_MCDiscreteGeometricAPEngineT_PseudoRandom_t,
  _swigc__p_MCEuropeanBasketEngineT_LowDiscrepancy_t,
  _swigc__p_MCEuropeanBasketEngineT_PseudoRandom_t,
  _swigc__p_MCEuropeanEngineT_LowDiscrepancy_t,
  _swigc__p_MCEuropeanEngineT_PseudoRandom_t,
  _swigc__p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t,
  _swigc__p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t,
  _swigc__p_MCEuropeanHestonEngineT_LowDiscrepancy_t,
  _swigc__p_MCEuropeanHestonEngineT_PseudoRandom_t,
  _swigc__p_MCEverestEngineT_LowDiscrepancy_t,
  _swigc__p_MCEverestEngineT_PseudoRandom_t,
  _swigc__p_MCHimalayaEngineT_LowDiscrepancy_t,
  _swigc__p_MCHimalayaEngineT_PseudoRandom_t,
  _swigc__p_MTBrownianGeneratorFactory,
  _swigc__p_MakeOIS,
  _swigc__p_MakeSchedule,
  _swigc__p_MakeVanillaSwap,
  _swigc__p_MarkovFunctional,
  _swigc__p_MarkovFunctional__ModelSettings,
  _swigc__p_Matrix,
  _swigc__p_MatrixMultiplicationProxy,
  _swigc__p_MatrixRow,
  _swigc__p_MaxBasketPayoff,
  _swigc__p_MersenneTwisterUniformRng,
  _swigc__p_Merton76Process,
  _swigc__p_MethodOfLinesScheme,
  _swigc__p_MidPointCdsEngine,
  _swigc__p_MinBasketPayoff,
  _swigc__p_MirrorGaussianSimulatedAnnealing,
  _swigc__p_ModifiedCraigSneydScheme,
  _swigc__p_Money,
  _swigc__p_MonotonicCubic,
  _swigc__p_MonotonicLogCubic,
  _swigc__p_MoroInverseCumulativeNormal,
  _swigc__p_Mosprime,
  _swigc__p_MultiAssetOption,
  _swigc__p_MultiPath,
  _swigc__p_MultiplicativePriceSeasonality,
  _swigc__p_NZDLibor,
  _swigc__p_NelsonSiegelFitting,
  _swigc__p_NeumannBC,
  _swigc__p_Newton,
  _swigc__p_NewtonSafe,
  _swigc__p_NinePointLinearOp,
  _swigc__p_NoArbSabrInterpolatedSmileSection,
  _swigc__p_NoArbSabrSmileSection,
  _swigc__p_NoConstraint,
  _swigc__p_NoExceptLocalVolSurface,
  _swigc__p_NonCentralCumulativeChiSquareDistribution,
  _swigc__p_NonhomogeneousBoundaryConstraint,
  _swigc__p_NonstandardSwap,
  _swigc__p_NonstandardSwaption,
  _swigc__p_NormalDistribution,
  _swigc__p_NthOrderDerivativeOp,
  _swigc__p_NullParameter,
  _swigc__p_NumericHaganPricer,
  _swigc__p_Nzocr,
  _swigc__p_OISRateHelper,
  _swigc__p_Observable,
  _swigc__p_OneAssetOption,
  _swigc__p_OneFactorAffineModel,
  _swigc__p_OptimizationMethod,
  _swigc__p_Optimizer,
  _swigc__p_Option,
  _swigc__p_OptionletStripper1,
  _swigc__p_OptionletVolatilityStructure,
  _swigc__p_OrnsteinUhlenbeckProcess,
  _swigc__p_OvernightIndex,
  _swigc__p_OvernightIndexFuture,
  _swigc__p_OvernightIndexFutureRateHelper,
  _swigc__p_OvernightIndexedCoupon,
  _swigc__p_OvernightIndexedSwap,
  _swigc__p_OvernightIndexedSwapIndex,
  _swigc__p_Parameter,
  _swigc__p_ParkinsonSigma,
  _swigc__p_Path,
  _swigc__p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t,
  _swigc__p_PathGeneratorT_GaussianRandomSequenceGenerator_t,
  _swigc__p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t,
  _swigc__p_Payoff,
  _swigc__p_PercentageStrikePayoff,
  _swigc__p_Period,
  _swigc__p_PeriodParser,
  _swigc__p_PiecewiseConstantParameter,
  _swigc__p_PiecewiseConvexMonotoneZero,
  _swigc__p_PiecewiseCubicZero,
  _swigc__p_PiecewiseFlatForward,
  _swigc__p_PiecewiseFlatHazardRate,
  _swigc__p_PiecewiseKrugerLogDiscount,
  _swigc__p_PiecewiseKrugerZero,
  _swigc__p_PiecewiseLinearForward,
  _swigc__p_PiecewiseLinearZero,
  _swigc__p_PiecewiseLogCubicDiscount,
  _swigc__p_PiecewiseLogLinearDiscount,
  _swigc__p_PiecewiseSplineCubicDiscount,
  _swigc__p_PiecewiseTimeDependentHestonModel,
  _swigc__p_PiecewiseYoYInflationCurveT_Linear_t,
  _swigc__p_PiecewiseZeroInflationCurveT_Linear_t,
  _swigc__p_Pillar,
  _swigc__p_PlainVanillaPayoff,
  _swigc__p_PoissonDistribution,
  _swigc__p_Position,
  _swigc__p_PositiveConstraint,
  _swigc__p_Predefined1dMesher,
  _swigc__p_Pribor,
  _swigc__p_PricingEngine,
  _swigc__p_ProbabilityBoltzmannDownhill,
  _swigc__p_Protection,
  _swigc__p_PyObserver,
  _swigc__p_QuantLib__ARSCurrency,
  _swigc__p_QuantLib__ATSCurrency,
  _swigc__p_QuantLib__AUDCurrency,
  _swigc__p_QuantLib__Actual360,
  _swigc__p_QuantLib__Actual364,
  _swigc__p_QuantLib__Actual365Fixed,
  _swigc__p_QuantLib__ActualActual,
  _swigc__p_QuantLib__Argentina,
  _swigc__p_QuantLib__Australia,
  _swigc__p_QuantLib__BDTCurrency,
  _swigc__p_QuantLib__BEFCurrency,
  _swigc__p_QuantLib__BGLCurrency,
  _swigc__p_QuantLib__BRLCurrency,
  _swigc__p_QuantLib__BYRCurrency,
  _swigc__p_QuantLib__BespokeCalendar,
  _swigc__p_QuantLib__Brazil,
  _swigc__p_QuantLib__Business252,
  _swigc__p_QuantLib__CADCurrency,
  _swigc__p_QuantLib__CHFCurrency,
  _swigc__p_QuantLib__CLPCurrency,
  _swigc__p_QuantLib__CNYCurrency,
  _swigc__p_QuantLib__COPCurrency,
  _swigc__p_QuantLib__CYPCurrency,
  _swigc__p_QuantLib__CZKCurrency,
  _swigc__p_QuantLib__Canada,
  _swigc__p_QuantLib__China,
  _swigc__p_QuantLib__CzechRepublic,
  _swigc__p_QuantLib__DEMCurrency,
  _swigc__p_QuantLib__DKKCurrency,
  _swigc__p_QuantLib__Denmark,
  _swigc__p_QuantLib__EEKCurrency,
  _swigc__p_QuantLib__ESPCurrency,
  _swigc__p_QuantLib__EURCurrency,
  _swigc__p_QuantLib__FIMCurrency,
  _swigc__p_QuantLib__FRFCurrency,
  _swigc__p_QuantLib__Finland,
  _swigc__p_QuantLib__France,
  _swigc__p_QuantLib__GBPCurrency,
  _swigc__p_QuantLib__GRDCurrency,
  _swigc__p_QuantLib__Germany,
  _swigc__p_QuantLib__HKDCurrency,
  _swigc__p_QuantLib__HUFCurrency,
  _swigc__p_QuantLib__HongKong,
  _swigc__p_QuantLib__Hungary,
  _swigc__p_QuantLib__IDRCurrency,
  _swigc__p_QuantLib__IEPCurrency,
  _swigc__p_QuantLib__ILSCurrency,
  _swigc__p_QuantLib__INRCurrency,
  _swigc__p_QuantLib__IQDCurrency,
  _swigc__p_QuantLib__IRRCurrency,
  _swigc__p_QuantLib__ISKCurrency,
  _swigc__p_QuantLib__ITLCurrency,
  _swigc__p_QuantLib__Iceland,
  _swigc__p_QuantLib__India,
  _swigc__p_QuantLib__Indonesia,
  _swigc__p_QuantLib__Israel,
  _swigc__p_QuantLib__Italy,
  _swigc__p_QuantLib__JPYCurrency,
  _swigc__p_QuantLib__Japan,
  _swigc__p_QuantLib__JointCalendar,
  _swigc__p_QuantLib__KRWCurrency,
  _swigc__p_QuantLib__KWDCurrency,
  _swigc__p_QuantLib__LTLCurrency,
  _swigc__p_QuantLib__LUFCurrency,
  _swigc__p_QuantLib__LVLCurrency,
  _swigc__p_QuantLib__MTLCurrency,
  _swigc__p_QuantLib__MXNCurrency,
  _swigc__p_QuantLib__MYRCurrency,
  _swigc__p_QuantLib__Mexico,
  _swigc__p_QuantLib__NLGCurrency,
  _swigc__p_QuantLib__NOKCurrency,
  _swigc__p_QuantLib__NPRCurrency,
  _swigc__p_QuantLib__NZDCurrency,
  _swigc__p_QuantLib__NewZealand,
  _swigc__p_QuantLib__Norway,
  _swigc__p_QuantLib__NullCalendar,
  _swigc__p_QuantLib__OneDayCounter,
  _swigc__p_QuantLib__PEHCurrency,
  _swigc__p_QuantLib__PEICurrency,
  _swigc__p_QuantLib__PENCurrency,
  _swigc__p_QuantLib__PKRCurrency,
  _swigc__p_QuantLib__PLNCurrency,
  _swigc__p_QuantLib__PTECurrency,
  _swigc__p_QuantLib__Poland,
  _swigc__p_QuantLib__ROLCurrency,
  _swigc__p_QuantLib__RONCurrency,
  _swigc__p_QuantLib__RUBCurrency,
  _swigc__p_QuantLib__Romania,
  _swigc__p_QuantLib__Russia,
  _swigc__p_QuantLib__SARCurrency,
  _swigc__p_QuantLib__SEKCurrency,
  _swigc__p_QuantLib__SGDCurrency,
  _swigc__p_QuantLib__SITCurrency,
  _swigc__p_QuantLib__SKKCurrency,
  _swigc__p_QuantLib__SaudiArabia,
  _swigc__p_QuantLib__SimpleDayCounter,
  _swigc__p_QuantLib__Singapore,
  _swigc__p_QuantLib__Slovakia,
  _swigc__p_QuantLib__SouthAfrica,
  _swigc__p_QuantLib__SouthKorea,
  _swigc__p_QuantLib__Sweden,
  _swigc__p_QuantLib__Switzerland,
  _swigc__p_QuantLib__TARGET,
  _swigc__p_QuantLib__THBCurrency,
  _swigc__p_QuantLib__TRLCurrency,
  _swigc__p_QuantLib__TRYCurrency,
  _swigc__p_QuantLib__TTDCurrency,
  _swigc__p_QuantLib__TWDCurrency,
  _swigc__p_QuantLib__Taiwan,
  _swigc__p_QuantLib__Thailand,
  _swigc__p_QuantLib__Thirty360,
  _swigc__p_QuantLib__Thirty365,
  _swigc__p_QuantLib__Turkey,
  _swigc__p_QuantLib__USDCurrency,
  _swigc__p_QuantLib__Ukraine,
  _swigc__p_QuantLib__UnitedKingdom,
  _swigc__p_QuantLib__UnitedStates,
  _swigc__p_QuantLib__VEBCurrency,
  _swigc__p_QuantLib__VNDCurrency,
  _swigc__p_QuantLib__WeekendsOnly,
  _swigc__p_QuantLib__ZARCurrency,
  _swigc__p_QuantoDoubleBarrierOption,
  _swigc__p_QuantoEuropeanEngine,
  _swigc__p_QuantoForwardEuropeanEngine,
  _swigc__p_QuantoForwardVanillaOption,
  _swigc__p_QuantoVanillaOption,
  _swigc__p_Quote,
  _swigc__p_RandomSequenceGeneratorT_KnuthUniformRng_t,
  _swigc__p_RandomSequenceGeneratorT_LecuyerUniformRng_t,
  _swigc__p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t,
  _swigc__p_RateHelper,
  _swigc__p_RealTimeSeries,
  _swigc__p_ReannealingTrivial,
  _swigc__p_RebatedExercise,
  _swigc__p_Redemption,
  _swigc__p_Region,
  _swigc__p_RelinkableHandleT_BlackVolTermStructure_t,
  _swigc__p_RelinkableHandleT_CalibratedModel_t,
  _swigc__p_RelinkableHandleT_CapFloorTermVolatilityStructure_t,
  _swigc__p_RelinkableHandleT_DefaultProbabilityTermStructure_t,
  _swigc__p_RelinkableHandleT_DeltaVolQuote_t,
  _swigc__p_RelinkableHandleT_LocalVolTermStructure_t,
  _swigc__p_RelinkableHandleT_OptionletVolatilityStructure_t,
  _swigc__p_RelinkableHandleT_Quote_t,
  _swigc__p_RelinkableHandleT_ShortRateModel_t,
  _swigc__p_RelinkableHandleT_SwaptionVolatilityStructure_t,
  _swigc__p_RelinkableHandleT_YieldTermStructure_t,
  _swigc__p_RelinkableHandleT_YoYInflationTermStructure_t,
  _swigc__p_RelinkableHandleT_YoYOptionletVolatilitySurface_t,
  _swigc__p_RelinkableHandleT_ZeroInflationTermStructure_t,
  _swigc__p_RichardsonExtrapolation,
  _swigc__p_Ridder,
  _swigc__p_RiskNeutralDensityCalculator,
  _swigc__p_RiskStatistics,
  _swigc__p_Robor,
  _swigc__p_Rounding,
  _swigc__p_SEKLibor,
  _swigc__p_SVD,
  _swigc__p_SabrSmileSection,
  _swigc__p_SafeBackwardFlatInterpolation,
  _swigc__p_SafeBicubicSpline,
  _swigc__p_SafeBilinearInterpolation,
  _swigc__p_SafeConvexMonotoneInterpolation,
  _swigc__p_SafeCubicNaturalSpline,
  _swigc__p_SafeForwardFlatInterpolation,
  _swigc__p_SafeFritschButlandCubic,
  _swigc__p_SafeFritschButlandLogCubic,
  _swigc__p_SafeKrugerCubic,
  _swigc__p_SafeKrugerLogCubic,
  _swigc__p_SafeLinearInterpolation,
  _swigc__p_SafeLogCubicNaturalSpline,
  _swigc__p_SafeLogLinearInterpolation,
  _swigc__p_SafeLogParabolic,
  _swigc__p_SafeMonotonicCubicNaturalSpline,
  _swigc__p_SafeMonotonicLogCubicNaturalSpline,
  _swigc__p_SafeMonotonicLogParabolic,
  _swigc__p_SafeMonotonicParabolic,
  _swigc__p_SafeParabolic,
  _swigc__p_SafeSABRInterpolation,
  _swigc__p_SalvagingAlgorithm,
  _swigc__p_SampleT_Array_t,
  _swigc__p_SampleT_MultiPath_t,
  _swigc__p_SampleT_Path_t,
  _swigc__p_SampleT_double_t,
  _swigc__p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t,
  _swigc__p_SampledCurve,
  _swigc__p_SamplerGaussian,
  _swigc__p_SamplerLogNormal,
  _swigc__p_SamplerMirrorGaussian,
  _swigc__p_Schedule,
  _swigc__p_Seasonality,
  _swigc__p_Secant,
  _swigc__p_SecondDerivativeOp,
  _swigc__p_SecondOrderMixedDerivativeOp,
  _swigc__p_SegmentIntegral,
  _swigc__p_Settings,
  _swigc__p_Settlement,
  _swigc__p_Shibor,
  _swigc__p_ShortRateModel,
  _swigc__p_Side,
  _swigc__p_SimpleCashFlow,
  _swigc__p_SimplePolynomialFitting,
  _swigc__p_SimpleQuote,
  _swigc__p_Simplex,
  _swigc__p_SimpsonIntegral,
  _swigc__p_SmileSection,
  _swigc__p_SobolBrownianBridgeRsg,
  _swigc__p_SobolBrownianGenerator,
  _swigc__p_SobolBrownianGeneratorFactory,
  _swigc__p_SobolRsg,
  _swigc__p_Sofr,
  _swigc__p_SofrFutureRateHelper,
  _swigc__p_SoftCallability,
  _swigc__p_Sonia,
  _swigc__p_SplineCubic,
  _swigc__p_SpreadBasketPayoff,
  _swigc__p_SpreadCdsHelper,
  _swigc__p_SpreadOption,
  _swigc__p_SquareRootProcessRNDCalculator,
  _swigc__p_Statistics,
  _swigc__p_SteepestDescent,
  _swigc__p_StepConditionT_Array_t,
  _swigc__p_StochasticProcess,
  _swigc__p_StochasticProcess1D,
  _swigc__p_StochasticProcessArray,
  _swigc__p_Stock,
  _swigc__p_StrikedTypePayoff,
  _swigc__p_StrippedOptionletAdapter,
  _swigc__p_StrippedOptionletBase,
  _swigc__p_StudentDistribution,
  _swigc__p_StulzEngine,
  _swigc__p_SuperSharePayoff,
  _swigc__p_SvenssonFitting,
  _swigc__p_Swap,
  _swigc__p_SwapIndex,
  _swigc__p_SwapRateHelper,
  _swigc__p_SwapSpreadIndex,
  _swigc__p_Swaption,
  _swigc__p_SwaptionHelper,
  _swigc__p_SwaptionVolCube1,
  _swigc__p_SwaptionVolCube2,
  _swigc__p_SwaptionVolatilityCube,
  _swigc__p_SwaptionVolatilityDiscrete,
  _swigc__p_SwaptionVolatilityMatrix,
  _swigc__p_SwaptionVolatilityStructure,
  _swigc__p_SwingExercise,
  _swigc__p_THBFIX,
  _swigc__p_TRLibor,
  _swigc__p_TemperatureExponential,
  _swigc__p_TermStructure,
  _swigc__p_TermStructureConsistentModel,
  _swigc__p_Tibor,
  _swigc__p_TimeBasket,
  _swigc__p_TimeGrid,
  _swigc__p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,
  _swigc__p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t,
  _swigc__p_TrapezoidIntegralT_Default_t,
  _swigc__p_TrapezoidIntegralT_MidPoint_t,
  _swigc__p_TreeCallableFixedRateBondEngine,
  _swigc__p_TreeCapFloorEngine,
  _swigc__p_TreeSwaptionEngine,
  _swigc__p_TridiagonalOperator,
  _swigc__p_TripleBandLinearOp,
  _swigc__p_TypePayoff,
  _swigc__p_UKRPI,
  _swigc__p_USCPI,
  _swigc__p_USDLibor,
  _swigc__p_USDLiborON,
  _swigc__p_Uniform1dMesher,
  _swigc__p_UniformLowDiscrepancySequenceGenerator,
  _swigc__p_UniformRandomGenerator,
  _swigc__p_UniformRandomSequenceGenerator,
  _swigc__p_UpRounding,
  _swigc__p_UpfrontCdsHelper,
  _swigc__p_UsdLiborSwapIsdaFixAm,
  _swigc__p_UsdLiborSwapIsdaFixPm,
  _swigc__p_VanillaForwardPayoff,
  _swigc__p_VanillaOption,
  _swigc__p_VanillaSwap,
  _swigc__p_VanillaSwingOption,
  _swigc__p_VannaVolgaBarrierEngine,
  _swigc__p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t,
  _swigc__p_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t,
  _swigc__p_VarianceGammaEngine,
  _swigc__p_VarianceGammaProcess,
  _swigc__p_Vasicek,
  _swigc__p_VolatilityTermStructure,
  _swigc__p_Wibor,
  _swigc__p_WulinYongDoubleBarrierEngine,
  _swigc__p_YYEUHICP,
  _swigc__p_YYEUHICPXT,
  _swigc__p_YYEUHICPr,
  _swigc__p_YYFRHICP,
  _swigc__p_YYFRHICPr,
  _swigc__p_YYUKRPI,
  _swigc__p_YYUKRPIr,
  _swigc__p_YYUSCPI,
  _swigc__p_YYUSCPIr,
  _swigc__p_YYZACPI,
  _swigc__p_YYZACPIr,
  _swigc__p_YearOnYearInflationSwap,
  _swigc__p_YearOnYearInflationSwapHelper,
  _swigc__p_YieldTermStructure,
  _swigc__p_YoYCapFloorTermPriceSurface,
  _swigc__p_YoYInflationBachelierCapFloorEngine,
  _swigc__p_YoYInflationBlackCapFloorEngine,
  _swigc__p_YoYInflationCap,
  _swigc__p_YoYInflationCapFloor,
  _swigc__p_YoYInflationCapFloorTermPriceSurface,
  _swigc__p_YoYInflationCollar,
  _swigc__p_YoYInflationFloor,
  _swigc__p_YoYInflationIndex,
  _swigc__p_YoYInflationTermStructure,
  _swigc__p_YoYInflationUnitDisplacedBlackCapFloorEngine,
  _swigc__p_YoYOptionletHelper,
  _swigc__p_YoYOptionletStripper,
  _swigc__p_YoYOptionletVolatilitySurface,
  _swigc__p_ZACPI,
  _swigc__p_ZabrFullFd,
  _swigc__p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t,
  _swigc__p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t,
  _swigc__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t,
  _swigc__p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t,
  _swigc__p_ZabrLocalVolatility,
  _swigc__p_ZabrShortMaturityLognormal,
  _swigc__p_ZabrShortMaturityNormal,
  _swigc__p_ZabrSmileSectionT_ZabrFullFd_t,
  _swigc__p_ZabrSmileSectionT_ZabrLocalVolatility_t,
  _swigc__p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t,
  _swigc__p_ZabrSmileSectionT_ZabrShortMaturityNormal_t,
  _swigc__p_ZeroCouponBond,
  _swigc__p_ZeroCouponInflationSwap,
  _swigc__p_ZeroCouponInflationSwapHelper,
  _swigc__p_ZeroInflationIndex,
  _swigc__p_ZeroInflationTermStructure,
  _swigc__p_ZeroSpreadedTermStructure,
  _swigc__p_ZeroYield,
  _swigc__p_Zibor,
  _swigc__p__GlobalBootstrap,
  _swigc__p__IterativeBootstrap,
  _swigc__p_allocator_type,
  _swigc__p_char,
  _swigc__p_const_reference,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_ext__functionT_double_fdoubleF_t,
  _swigc__p_ext__shared_ptrT_AUCPI_t,
  _swigc__p_ext__shared_ptrT_AUDLibor_t,
  _swigc__p_ext__shared_ptrT_AmericanExercise_t,
  _swigc__p_ext__shared_ptrT_AmortizingFixedRateBond_t,
  _swigc__p_ext__shared_ptrT_AmortizingFloatingRateBond_t,
  _swigc__p_ext__shared_ptrT_AmortizingPayment_t,
  _swigc__p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticCEVEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticEuropeanEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticHaganPricer_t,
  _swigc__p_ext__shared_ptrT_AnalyticHestonEngine_t,
  _swigc__p_ext__shared_ptrT_AnalyticPTDHestonEngine_t,
  _swigc__p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t,
  _swigc__p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t,
  _swigc__p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t,
  _swigc__p_ext__shared_ptrT_Aonia_t,
  _swigc__p_ext__shared_ptrT_AssetOrNothingPayoff_t,
  _swigc__p_ext__shared_ptrT_AssetSwap_t,
  _swigc__p_ext__shared_ptrT_AverageBasketPayoff_t,
  _swigc__p_ext__shared_ptrT_BFGS_t,
  _swigc__p_ext__shared_ptrT_BSMRNDCalculator_t,
  _swigc__p_ext__shared_ptrT_BachelierCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_BachelierSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t,
  _swigc__p_ext__shared_ptrT_BarrierOption_t,
  _swigc__p_ext__shared_ptrT_BasketOption_t,
  _swigc__p_ext__shared_ptrT_BasketPayoff_t,
  _swigc__p_ext__shared_ptrT_BatesEngine_t,
  _swigc__p_ext__shared_ptrT_BatesModel_t,
  _swigc__p_ext__shared_ptrT_BatesProcess_t,
  _swigc__p_ext__shared_ptrT_Bbsw1M_t,
  _swigc__p_ext__shared_ptrT_Bbsw2M_t,
  _swigc__p_ext__shared_ptrT_Bbsw3M_t,
  _swigc__p_ext__shared_ptrT_Bbsw4M_t,
  _swigc__p_ext__shared_ptrT_Bbsw5M_t,
  _swigc__p_ext__shared_ptrT_Bbsw6M_t,
  _swigc__p_ext__shared_ptrT_Bbsw_t,
  _swigc__p_ext__shared_ptrT_BermudanExercise_t,
  _swigc__p_ext__shared_ptrT_BiCGstab_t,
  _swigc__p_ext__shared_ptrT_Bibor1M_t,
  _swigc__p_ext__shared_ptrT_Bibor1Y_t,
  _swigc__p_ext__shared_ptrT_Bibor2M_t,
  _swigc__p_ext__shared_ptrT_Bibor3M_t,
  _swigc__p_ext__shared_ptrT_Bibor6M_t,
  _swigc__p_ext__shared_ptrT_Bibor9M_t,
  _swigc__p_ext__shared_ptrT_BiborSW_t,
  _swigc__p_ext__shared_ptrT_Bibor_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t,
  _swigc__p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t,
  _swigc__p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t,
  _swigc__p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t,
  _swigc__p_ext__shared_ptrT_Bkbm1M_t,
  _swigc__p_ext__shared_ptrT_Bkbm2M_t,
  _swigc__p_ext__shared_ptrT_Bkbm3M_t,
  _swigc__p_ext__shared_ptrT_Bkbm4M_t,
  _swigc__p_ext__shared_ptrT_Bkbm5M_t,
  _swigc__p_ext__shared_ptrT_Bkbm6M_t,
  _swigc__p_ext__shared_ptrT_Bkbm_t,
  _swigc__p_ext__shared_ptrT_BlackCalibrationHelper_t,
  _swigc__p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t,
  _swigc__p_ext__shared_ptrT_BlackCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_BlackCdsOptionEngine_t,
  _swigc__p_ext__shared_ptrT_BlackConstantVol_t,
  _swigc__p_ext__shared_ptrT_BlackIborCouponPricer_t,
  _swigc__p_ext__shared_ptrT_BlackKarasinski_t,
  _swigc__p_ext__shared_ptrT_BlackProcess_t,
  _swigc__p_ext__shared_ptrT_BlackScholesMertonProcess_t,
  _swigc__p_ext__shared_ptrT_BlackScholesProcess_t,
  _swigc__p_ext__shared_ptrT_BlackSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_BlackVarianceCurve_t,
  _swigc__p_ext__shared_ptrT_BlackVarianceSurface_t,
  _swigc__p_ext__shared_ptrT_BlackVolTermStructure_t,
  _swigc__p_ext__shared_ptrT_BondHelper_t,
  _swigc__p_ext__shared_ptrT_Bond_t,
  _swigc__p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,
  _swigc__p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,
  _swigc__p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,
  _swigc__p_ext__shared_ptrT_BoundaryConstraint_t,
  _swigc__p_ext__shared_ptrT_BrownianGeneratorFactory_t,
  _swigc__p_ext__shared_ptrT_CADLiborON_t,
  _swigc__p_ext__shared_ptrT_CADLibor_t,
  _swigc__p_ext__shared_ptrT_CEVRNDCalculator_t,
  _swigc__p_ext__shared_ptrT_CHFLibor_t,
  _swigc__p_ext__shared_ptrT_COSHestonEngine_t,
  _swigc__p_ext__shared_ptrT_CPIBond_t,
  _swigc__p_ext__shared_ptrT_CPICoupon_t,
  _swigc__p_ext__shared_ptrT_CPISwap_t,
  _swigc__p_ext__shared_ptrT_CalibratedModel_t,
  _swigc__p_ext__shared_ptrT_CalibrationHelper_t,
  _swigc__p_ext__shared_ptrT_Callability_t,
  _swigc__p_ext__shared_ptrT_CallableBond_t,
  _swigc__p_ext__shared_ptrT_CallableFixedRateBond_t,
  _swigc__p_ext__shared_ptrT_CallableZeroCouponBond_t,
  _swigc__p_ext__shared_ptrT_CapFloorTermVolCurve_t,
  _swigc__p_ext__shared_ptrT_CapFloorTermVolSurface_t,
  _swigc__p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t,
  _swigc__p_ext__shared_ptrT_CapFloor_t,
  _swigc__p_ext__shared_ptrT_CapHelper_t,
  _swigc__p_ext__shared_ptrT_Cap_t,
  _swigc__p_ext__shared_ptrT_CappedFlooredCmsCoupon_t,
  _swigc__p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t,
  _swigc__p_ext__shared_ptrT_CappedFlooredCoupon_t,
  _swigc__p_ext__shared_ptrT_CappedFlooredIborCoupon_t,
  _swigc__p_ext__shared_ptrT_CashFlow_t,
  _swigc__p_ext__shared_ptrT_CashOrNothingPayoff_t,
  _swigc__p_ext__shared_ptrT_Cdor_t,
  _swigc__p_ext__shared_ptrT_CdsOption_t,
  _swigc__p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t,
  _swigc__p_ext__shared_ptrT_Claim_t,
  _swigc__p_ext__shared_ptrT_CmsCouponPricer_t,
  _swigc__p_ext__shared_ptrT_CmsCoupon_t,
  _swigc__p_ext__shared_ptrT_CmsMarket_t,
  _swigc__p_ext__shared_ptrT_CmsRateBond_t,
  _swigc__p_ext__shared_ptrT_CmsSpreadCouponPricer_t,
  _swigc__p_ext__shared_ptrT_CmsSpreadCoupon_t,
  _swigc__p_ext__shared_ptrT_Collar_t,
  _swigc__p_ext__shared_ptrT_CompositeConstraint_t,
  _swigc__p_ext__shared_ptrT_CompositeInstrument_t,
  _swigc__p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t,
  _swigc__p_ext__shared_ptrT_Concentrating1dMesher_t,
  _swigc__p_ext__shared_ptrT_ConjugateGradient_t,
  _swigc__p_ext__shared_ptrT_ConstantOptionletVolatility_t,
  _swigc__p_ext__shared_ptrT_ConstantSwaptionVolatility_t,
  _swigc__p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t,
  _swigc__p_ext__shared_ptrT_Constraint_t,
  _swigc__p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t,
  _swigc__p_ext__shared_ptrT_ContinuousAveragingAsianOption_t,
  _swigc__p_ext__shared_ptrT_ConvertibleFixedCouponBond_t,
  _swigc__p_ext__shared_ptrT_ConvertibleFloatingRateBond_t,
  _swigc__p_ext__shared_ptrT_ConvertibleZeroCouponBond_t,
  _swigc__p_ext__shared_ptrT_Coupon_t,
  _swigc__p_ext__shared_ptrT_CoxIngersollRoss_t,
  _swigc__p_ext__shared_ptrT_CraigSneydScheme_t,
  _swigc__p_ext__shared_ptrT_CrankNicolsonScheme_t,
  _swigc__p_ext__shared_ptrT_CreditDefaultSwap_t,
  _swigc__p_ext__shared_ptrT_DKKLibor_t,
  _swigc__p_ext__shared_ptrT_DailyTenorLibor_t,
  _swigc__p_ext__shared_ptrT_DatedOISRateHelper_t,
  _swigc__p_ext__shared_ptrT_DefaultBoundaryCondition_t,
  _swigc__p_ext__shared_ptrT_DefaultProbabilityHelper_t,
  _swigc__p_ext__shared_ptrT_DefaultProbabilityTermStructure_t,
  _swigc__p_ext__shared_ptrT_DeltaVolQuote_t,
  _swigc__p_ext__shared_ptrT_DepositRateHelper_t,
  _swigc__p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t,
  _swigc__p_ext__shared_ptrT_DifferentialEvolution_t,
  _swigc__p_ext__shared_ptrT_DirichletBC_t,
  _swigc__p_ext__shared_ptrT_DiscountingBondEngine_t,
  _swigc__p_ext__shared_ptrT_DiscountingSwapEngine_t,
  _swigc__p_ext__shared_ptrT_DiscreteAveragingAsianOption_t,
  _swigc__p_ext__shared_ptrT_DividendBarrierOption_t,
  _swigc__p_ext__shared_ptrT_DividendVanillaOption_t,
  _swigc__p_ext__shared_ptrT_Dividend_t,
  _swigc__p_ext__shared_ptrT_DoubleBarrierOption_t,
  _swigc__p_ext__shared_ptrT_DouglasScheme_t,
  _swigc__p_ext__shared_ptrT_EUHICPXT_t,
  _swigc__p_ext__shared_ptrT_EUHICP_t,
  _swigc__p_ext__shared_ptrT_EURLibor10M_t,
  _swigc__p_ext__shared_ptrT_EURLibor11M_t,
  _swigc__p_ext__shared_ptrT_EURLibor1M_t,
  _swigc__p_ext__shared_ptrT_EURLibor1Y_t,
  _swigc__p_ext__shared_ptrT_EURLibor2M_t,
  _swigc__p_ext__shared_ptrT_EURLibor2W_t,
  _swigc__p_ext__shared_ptrT_EURLibor3M_t,
  _swigc__p_ext__shared_ptrT_EURLibor4M_t,
  _swigc__p_ext__shared_ptrT_EURLibor5M_t,
  _swigc__p_ext__shared_ptrT_EURLibor6M_t,
  _swigc__p_ext__shared_ptrT_EURLibor7M_t,
  _swigc__p_ext__shared_ptrT_EURLibor8M_t,
  _swigc__p_ext__shared_ptrT_EURLibor9M_t,
  _swigc__p_ext__shared_ptrT_EURLiborSW_t,
  _swigc__p_ext__shared_ptrT_EURLibor_t,
  _swigc__p_ext__shared_ptrT_EndCriteria_t,
  _swigc__p_ext__shared_ptrT_Eonia_t,
  _swigc__p_ext__shared_ptrT_EurLiborSwapIfrFix_t,
  _swigc__p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t,
  _swigc__p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t,
  _swigc__p_ext__shared_ptrT_Euribor10M_t,
  _swigc__p_ext__shared_ptrT_Euribor11M_t,
  _swigc__p_ext__shared_ptrT_Euribor1M_t,
  _swigc__p_ext__shared_ptrT_Euribor1Y_t,
  _swigc__p_ext__shared_ptrT_Euribor2M_t,
  _swigc__p_ext__shared_ptrT_Euribor2W_t,
  _swigc__p_ext__shared_ptrT_Euribor365_10M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_11M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_1M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_1Y_t,
  _swigc__p_ext__shared_ptrT_Euribor365_2M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_2W_t,
  _swigc__p_ext__shared_ptrT_Euribor365_3M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_3W_t,
  _swigc__p_ext__shared_ptrT_Euribor365_4M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_5M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_6M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_7M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_8M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_9M_t,
  _swigc__p_ext__shared_ptrT_Euribor365_SW_t,
  _swigc__p_ext__shared_ptrT_Euribor365_t,
  _swigc__p_ext__shared_ptrT_Euribor3M_t,
  _swigc__p_ext__shared_ptrT_Euribor3W_t,
  _swigc__p_ext__shared_ptrT_Euribor4M_t,
  _swigc__p_ext__shared_ptrT_Euribor5M_t,
  _swigc__p_ext__shared_ptrT_Euribor6M_t,
  _swigc__p_ext__shared_ptrT_Euribor7M_t,
  _swigc__p_ext__shared_ptrT_Euribor8M_t,
  _swigc__p_ext__shared_ptrT_Euribor9M_t,
  _swigc__p_ext__shared_ptrT_EuriborSW_t,
  _swigc__p_ext__shared_ptrT_EuriborSwapIfrFix_t,
  _swigc__p_ext__shared_ptrT_EuriborSwapIsdaFixA_t,
  _swigc__p_ext__shared_ptrT_EuriborSwapIsdaFixB_t,
  _swigc__p_ext__shared_ptrT_Euribor_t,
  _swigc__p_ext__shared_ptrT_EuropeanExercise_t,
  _swigc__p_ext__shared_ptrT_EuropeanOption_t,
  _swigc__p_ext__shared_ptrT_EverestOption_t,
  _swigc__p_ext__shared_ptrT_Exercise_t,
  _swigc__p_ext__shared_ptrT_ExplicitEulerScheme_t,
  _swigc__p_ext__shared_ptrT_ExponentialFittingHestonEngine_t,
  _swigc__p_ext__shared_ptrT_ExponentialJump1dMesher_t,
  _swigc__p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,
  _swigc__p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t,
  _swigc__p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t,
  _swigc__p_ext__shared_ptrT_FDAmericanEngineT_CrankNicolson_t_t,
  _swigc__p_ext__shared_ptrT_FDBermudanEngineT_CrankNicolson_t_t,
  _swigc__p_ext__shared_ptrT_FDDividendAmericanEngineT_CrankNicolson_t_t,
  _swigc__p_ext__shared_ptrT_FDDividendEuropeanEngineT_CrankNicolson_t_t,
  _swigc__p_ext__shared_ptrT_FDEuropeanEngineT_CrankNicolson_t_t,
  _swigc__p_ext__shared_ptrT_FDShoutEngineT_CrankNicolson_t_t,
  _swigc__p_ext__shared_ptrT_FFTVarianceGammaEngine_t,
  _swigc__p_ext__shared_ptrT_FRHICP_t,
  _swigc__p_ext__shared_ptrT_FaceValueAccrualClaim_t,
  _swigc__p_ext__shared_ptrT_FaceValueClaim_t,
  _swigc__p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdBatesVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdBlackScholesAsianEngine_t,
  _swigc__p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_FdBlackScholesRebateEngine_t,
  _swigc__p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdCEVVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdG2SwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_FdHestonBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_FdHestonRebateEngine_t,
  _swigc__p_ext__shared_ptrT_FdHestonVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdSabrVanillaEngine_t,
  _swigc__p_ext__shared_ptrT_FdSimpleBSSwingEngine_t,
  _swigc__p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t,
  _swigc__p_ext__shared_ptrT_Fdm1DimSolver_t,
  _swigc__p_ext__shared_ptrT_Fdm1dMesher_t,
  _swigc__p_ext__shared_ptrT_Fdm2DimSolver_t,
  _swigc__p_ext__shared_ptrT_Fdm2dBlackScholesOp_t,
  _swigc__p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t,
  _swigc__p_ext__shared_ptrT_Fdm3DimSolver_t,
  _swigc__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t,
  _swigc__p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t,
  _swigc__p_ext__shared_ptrT_FdmAmericanStepCondition_t,
  _swigc__p_ext__shared_ptrT_FdmArithmeticAverageCondition_t,
  _swigc__p_ext__shared_ptrT_FdmBackwardSolver_t,
  _swigc__p_ext__shared_ptrT_FdmBatesOp_t,
  _swigc__p_ext__shared_ptrT_FdmBermudanStepCondition_t,
  _swigc__p_ext__shared_ptrT_FdmBlackScholesFwdOp_t,
  _swigc__p_ext__shared_ptrT_FdmBlackScholesMesher_t,
  _swigc__p_ext__shared_ptrT_FdmBlackScholesOp_t,
  _swigc__p_ext__shared_ptrT_FdmBoundaryCondition_t,
  _swigc__p_ext__shared_ptrT_FdmCEV1dMesher_t,
  _swigc__p_ext__shared_ptrT_FdmCEVOp_t,
  _swigc__p_ext__shared_ptrT_FdmCellAveragingInnerValue_t,
  _swigc__p_ext__shared_ptrT_FdmDirichletBoundary_t,
  _swigc__p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t,
  _swigc__p_ext__shared_ptrT_FdmDividendHandler_t,
  _swigc__p_ext__shared_ptrT_FdmDupire1dOp_t,
  _swigc__p_ext__shared_ptrT_FdmG2Op_t,
  _swigc__p_ext__shared_ptrT_FdmG2Solver_t,
  _swigc__p_ext__shared_ptrT_FdmHestonFwdOp_t,
  _swigc__p_ext__shared_ptrT_FdmHestonHullWhiteOp_t,
  _swigc__p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t,
  _swigc__p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t,
  _swigc__p_ext__shared_ptrT_FdmHestonOp_t,
  _swigc__p_ext__shared_ptrT_FdmHestonSolver_t,
  _swigc__p_ext__shared_ptrT_FdmHestonVarianceMesher_t,
  _swigc__p_ext__shared_ptrT_FdmHullWhiteOp_t,
  _swigc__p_ext__shared_ptrT_FdmHullWhiteSolver_t,
  _swigc__p_ext__shared_ptrT_FdmIndicesOnBoundary_t,
  _swigc__p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t,
  _swigc__p_ext__shared_ptrT_FdmInnerValueCalculator_t,
  _swigc__p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t,
  _swigc__p_ext__shared_ptrT_FdmLinearOpComposite_t,
  _swigc__p_ext__shared_ptrT_FdmLinearOpLayout_t,
  _swigc__p_ext__shared_ptrT_FdmLinearOp_t,
  _swigc__p_ext__shared_ptrT_FdmLocalVolFwdOp_t,
  _swigc__p_ext__shared_ptrT_FdmLogBasketInnerValue_t,
  _swigc__p_ext__shared_ptrT_FdmLogInnerValue_t,
  _swigc__p_ext__shared_ptrT_FdmMesherComposite_t,
  _swigc__p_ext__shared_ptrT_FdmMesher_t,
  _swigc__p_ext__shared_ptrT_FdmNdimSolverT_4_t_t,
  _swigc__p_ext__shared_ptrT_FdmNdimSolverT_5_t_t,
  _swigc__p_ext__shared_ptrT_FdmNdimSolverT_6_t_t,
  _swigc__p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t,
  _swigc__p_ext__shared_ptrT_FdmQuantoHelper_t,
  _swigc__p_ext__shared_ptrT_FdmSabrOp_t,
  _swigc__p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t,
  _swigc__p_ext__shared_ptrT_FdmSimpleStorageCondition_t,
  _swigc__p_ext__shared_ptrT_FdmSimpleSwingCondition_t,
  _swigc__p_ext__shared_ptrT_FdmSnapshotCondition_t,
  _swigc__p_ext__shared_ptrT_FdmSquareRootFwdOp_t,
  _swigc__p_ext__shared_ptrT_FdmStepConditionComposite_t,
  _swigc__p_ext__shared_ptrT_FdmStepConditionProxy_t,
  _swigc__p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t,
  _swigc__p_ext__shared_ptrT_FdmZabrOp_t,
  _swigc__p_ext__shared_ptrT_FdmZeroInnerValue_t,
  _swigc__p_ext__shared_ptrT_FedFunds_t,
  _swigc__p_ext__shared_ptrT_FirstDerivativeOp_t,
  _swigc__p_ext__shared_ptrT_FittedBondDiscountCurve_t,
  _swigc__p_ext__shared_ptrT_FixedDividend_t,
  _swigc__p_ext__shared_ptrT_FixedRateBondForward_t,
  _swigc__p_ext__shared_ptrT_FixedRateBondHelper_t,
  _swigc__p_ext__shared_ptrT_FixedRateBond_t,
  _swigc__p_ext__shared_ptrT_FixedRateCoupon_t,
  _swigc__p_ext__shared_ptrT_FlatForward_t,
  _swigc__p_ext__shared_ptrT_FlatHazardRate_t,
  _swigc__p_ext__shared_ptrT_FlatSmileSection_t,
  _swigc__p_ext__shared_ptrT_FloatFloatSwap_t,
  _swigc__p_ext__shared_ptrT_FloatFloatSwaption_t,
  _swigc__p_ext__shared_ptrT_FloatingRateBond_t,
  _swigc__p_ext__shared_ptrT_FloatingRateCouponPricer_t,
  _swigc__p_ext__shared_ptrT_FloatingRateCoupon_t,
  _swigc__p_ext__shared_ptrT_Floor_t,
  _swigc__p_ext__shared_ptrT_ForwardEuropeanEngine_t,
  _swigc__p_ext__shared_ptrT_ForwardRateAgreement_t,
  _swigc__p_ext__shared_ptrT_ForwardSpreadedTermStructure_t,
  _swigc__p_ext__shared_ptrT_ForwardVanillaOption_t,
  _swigc__p_ext__shared_ptrT_Forward_t,
  _swigc__p_ext__shared_ptrT_FraRateHelper_t,
  _swigc__p_ext__shared_ptrT_FractionalDividend_t,
  _swigc__p_ext__shared_ptrT_FuturesRateHelper_t,
  _swigc__p_ext__shared_ptrT_FxSwapRateHelper_t,
  _swigc__p_ext__shared_ptrT_G2ForwardProcess_t,
  _swigc__p_ext__shared_ptrT_G2Process_t,
  _swigc__p_ext__shared_ptrT_G2SwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_G2_t,
  _swigc__p_ext__shared_ptrT_GBPLiborON_t,
  _swigc__p_ext__shared_ptrT_GBPLibor_t,
  _swigc__p_ext__shared_ptrT_GBSMRNDCalculator_t,
  _swigc__p_ext__shared_ptrT_GJRGARCHModel_t,
  _swigc__p_ext__shared_ptrT_GJRGARCHProcess_t,
  _swigc__p_ext__shared_ptrT_GMRES_t,
  _swigc__p_ext__shared_ptrT_GapPayoff_t,
  _swigc__p_ext__shared_ptrT_GarmanKohlagenProcess_t,
  _swigc__p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_Gaussian1dModel_t,
  _swigc__p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_GaussianSimulatedAnnealing_t,
  _swigc__p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t,
  _swigc__p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,
  _swigc__p_ext__shared_ptrT_GeometricBrownianMotionProcess_t,
  _swigc__p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t,
  _swigc__p_ext__shared_ptrT_Glued1dMesher_t,
  _swigc__p_ext__shared_ptrT_GsrProcess_t,
  _swigc__p_ext__shared_ptrT_Gsr_t,
  _swigc__p_ext__shared_ptrT_HestonBlackVolSurface_t,
  _swigc__p_ext__shared_ptrT_HestonModelHelper_t,
  _swigc__p_ext__shared_ptrT_HestonModel_t,
  _swigc__p_ext__shared_ptrT_HestonProcess_t,
  _swigc__p_ext__shared_ptrT_HestonRNDCalculator_t,
  _swigc__p_ext__shared_ptrT_HestonSLVProcess_t,
  _swigc__p_ext__shared_ptrT_HimalayaOption_t,
  _swigc__p_ext__shared_ptrT_HullWhiteForwardProcess_t,
  _swigc__p_ext__shared_ptrT_HullWhiteProcess_t,
  _swigc__p_ext__shared_ptrT_HullWhite_t,
  _swigc__p_ext__shared_ptrT_HundsdorferScheme_t,
  _swigc__p_ext__shared_ptrT_IborCouponPricer_t,
  _swigc__p_ext__shared_ptrT_IborCoupon_t,
  _swigc__p_ext__shared_ptrT_IborIndex_t,
  _swigc__p_ext__shared_ptrT_ImplicitEulerScheme_t,
  _swigc__p_ext__shared_ptrT_ImpliedTermStructure_t,
  _swigc__p_ext__shared_ptrT_Index_t,
  _swigc__p_ext__shared_ptrT_IndexedCashFlow_t,
  _swigc__p_ext__shared_ptrT_InflationCoupon_t,
  _swigc__p_ext__shared_ptrT_InflationIndex_t,
  _swigc__p_ext__shared_ptrT_InflationTermStructure_t,
  _swigc__p_ext__shared_ptrT_Instrument_t,
  _swigc__p_ext__shared_ptrT_IntegralCdsEngine_t,
  _swigc__p_ext__shared_ptrT_IntegralEngine_t,
  _swigc__p_ext__shared_ptrT_InterestRateIndex_t,
  _swigc__p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_BackwardFlat_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedPiecewiseZeroSpreadedTermStructureT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t,
  _swigc__p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_IsdaCdsEngine_t,
  _swigc__p_ext__shared_ptrT_JPYLibor_t,
  _swigc__p_ext__shared_ptrT_JamshidianSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_Jibar_t,
  _swigc__p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t,
  _swigc__p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t,
  _swigc__p_ext__shared_ptrT_JuQuadraticApproximationEngine_t,
  _swigc__p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_KahaleSmileSection_t,
  _swigc__p_ext__shared_ptrT_KerkhofSeasonality_t,
  _swigc__p_ext__shared_ptrT_KirkEngine_t,
  _swigc__p_ext__shared_ptrT_KirkSpreadOptionEngine_t,
  _swigc__p_ext__shared_ptrT_KlugeExtOUProcess_t,
  _swigc__p_ext__shared_ptrT_LevenbergMarquardt_t,
  _swigc__p_ext__shared_ptrT_Libor_t,
  _swigc__p_ext__shared_ptrT_LinearTsrPricer_t,
  _swigc__p_ext__shared_ptrT_LocalConstantVol_t,
  _swigc__p_ext__shared_ptrT_LocalVolRNDCalculator_t,
  _swigc__p_ext__shared_ptrT_LocalVolSurface_t,
  _swigc__p_ext__shared_ptrT_LocalVolTermStructure_t,
  _swigc__p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t,
  _swigc__p_ext__shared_ptrT_LognormalCmsSpreadPricer_t,
  _swigc__p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t,
  _swigc__p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t,
  _swigc__p_ext__shared_ptrT_MTBrownianGeneratorFactory_t,
  _swigc__p_ext__shared_ptrT_MarkovFunctional_t,
  _swigc__p_ext__shared_ptrT_MaxBasketPayoff_t,
  _swigc__p_ext__shared_ptrT_Merton76Process_t,
  _swigc__p_ext__shared_ptrT_MethodOfLinesScheme_t,
  _swigc__p_ext__shared_ptrT_MidPointCdsEngine_t,
  _swigc__p_ext__shared_ptrT_MinBasketPayoff_t,
  _swigc__p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t,
  _swigc__p_ext__shared_ptrT_ModifiedCraigSneydScheme_t,
  _swigc__p_ext__shared_ptrT_Mosprime_t,
  _swigc__p_ext__shared_ptrT_MultiAssetOption_t,
  _swigc__p_ext__shared_ptrT_MultiplicativePriceSeasonality_t,
  _swigc__p_ext__shared_ptrT_NZDLibor_t,
  _swigc__p_ext__shared_ptrT_NeumannBC_t,
  _swigc__p_ext__shared_ptrT_NinePointLinearOp_t,
  _swigc__p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t,
  _swigc__p_ext__shared_ptrT_NoArbSabrSmileSection_t,
  _swigc__p_ext__shared_ptrT_NoConstraint_t,
  _swigc__p_ext__shared_ptrT_NoExceptLocalVolSurface_t,
  _swigc__p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t,
  _swigc__p_ext__shared_ptrT_NonstandardSwap_t,
  _swigc__p_ext__shared_ptrT_NonstandardSwaption_t,
  _swigc__p_ext__shared_ptrT_NthOrderDerivativeOp_t,
  _swigc__p_ext__shared_ptrT_NumericHaganPricer_t,
  _swigc__p_ext__shared_ptrT_Nzocr_t,
  _swigc__p_ext__shared_ptrT_OISRateHelper_t,
  _swigc__p_ext__shared_ptrT_Observable_t,
  _swigc__p_ext__shared_ptrT_OneAssetOption_t,
  _swigc__p_ext__shared_ptrT_OneFactorAffineModel_t,
  _swigc__p_ext__shared_ptrT_OptimizationMethod_t,
  _swigc__p_ext__shared_ptrT_Option_t,
  _swigc__p_ext__shared_ptrT_OptionletStripper1_t,
  _swigc__p_ext__shared_ptrT_OptionletVolatilityStructure_t,
  _swigc__p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,
  _swigc__p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t,
  _swigc__p_ext__shared_ptrT_OvernightIndex_t,
  _swigc__p_ext__shared_ptrT_OvernightIndexedCoupon_t,
  _swigc__p_ext__shared_ptrT_OvernightIndexedSwapIndex_t,
  _swigc__p_ext__shared_ptrT_OvernightIndexedSwap_t,
  _swigc__p_ext__shared_ptrT_Payoff_t,
  _swigc__p_ext__shared_ptrT_PercentageStrikePayoff_t,
  _swigc__p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t,
  _swigc__p_ext__shared_ptrT_PiecewiseCubicZero_t,
  _swigc__p_ext__shared_ptrT_PiecewiseFlatForward_t,
  _swigc__p_ext__shared_ptrT_PiecewiseFlatHazardRate_t,
  _swigc__p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t,
  _swigc__p_ext__shared_ptrT_PiecewiseKrugerZero_t,
  _swigc__p_ext__shared_ptrT_PiecewiseLinearForward_t,
  _swigc__p_ext__shared_ptrT_PiecewiseLinearZero_t,
  _swigc__p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t,
  _swigc__p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t,
  _swigc__p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t,
  _swigc__p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,
  _swigc__p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t,
  _swigc__p_ext__shared_ptrT_PlainVanillaPayoff_t,
  _swigc__p_ext__shared_ptrT_PositiveConstraint_t,
  _swigc__p_ext__shared_ptrT_Predefined1dMesher_t,
  _swigc__p_ext__shared_ptrT_Pribor_t,
  _swigc__p_ext__shared_ptrT_PricingEngine_t,
  _swigc__p_ext__shared_ptrT_QuantoDoubleBarrierOption_t,
  _swigc__p_ext__shared_ptrT_QuantoEuropeanEngine_t,
  _swigc__p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t,
  _swigc__p_ext__shared_ptrT_QuantoForwardVanillaOption_t,
  _swigc__p_ext__shared_ptrT_QuantoVanillaOption_t,
  _swigc__p_ext__shared_ptrT_Quote_t,
  _swigc__p_ext__shared_ptrT_RateHelper_t,
  _swigc__p_ext__shared_ptrT_RebatedExercise_t,
  _swigc__p_ext__shared_ptrT_Redemption_t,
  _swigc__p_ext__shared_ptrT_RiskNeutralDensityCalculator_t,
  _swigc__p_ext__shared_ptrT_Robor_t,
  _swigc__p_ext__shared_ptrT_SEKLibor_t,
  _swigc__p_ext__shared_ptrT_SabrSmileSection_t,
  _swigc__p_ext__shared_ptrT_Seasonality_t,
  _swigc__p_ext__shared_ptrT_SecondDerivativeOp_t,
  _swigc__p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t,
  _swigc__p_ext__shared_ptrT_Shibor_t,
  _swigc__p_ext__shared_ptrT_ShortRateModel_t,
  _swigc__p_ext__shared_ptrT_SimpleCashFlow_t,
  _swigc__p_ext__shared_ptrT_SimpleQuote_t,
  _swigc__p_ext__shared_ptrT_Simplex_t,
  _swigc__p_ext__shared_ptrT_SmileSection_t,
  _swigc__p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t,
  _swigc__p_ext__shared_ptrT_SofrFutureRateHelper_t,
  _swigc__p_ext__shared_ptrT_Sofr_t,
  _swigc__p_ext__shared_ptrT_SoftCallability_t,
  _swigc__p_ext__shared_ptrT_Sonia_t,
  _swigc__p_ext__shared_ptrT_SpreadBasketPayoff_t,
  _swigc__p_ext__shared_ptrT_SpreadCdsHelper_t,
  _swigc__p_ext__shared_ptrT_SpreadOption_t,
  _swigc__p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t,
  _swigc__p_ext__shared_ptrT_SteepestDescent_t,
  _swigc__p_ext__shared_ptrT_StepConditionT_Array_t_t,
  _swigc__p_ext__shared_ptrT_StochasticProcess1D_t,
  _swigc__p_ext__shared_ptrT_StochasticProcessArray_t,
  _swigc__p_ext__shared_ptrT_StochasticProcess_t,
  _swigc__p_ext__shared_ptrT_Stock_t,
  _swigc__p_ext__shared_ptrT_StrikedTypePayoff_t,
  _swigc__p_ext__shared_ptrT_StrippedOptionletAdapter_t,
  _swigc__p_ext__shared_ptrT_StrippedOptionletBase_t,
  _swigc__p_ext__shared_ptrT_StulzEngine_t,
  _swigc__p_ext__shared_ptrT_SuperSharePayoff_t,
  _swigc__p_ext__shared_ptrT_SwapIndex_t,
  _swigc__p_ext__shared_ptrT_SwapRateHelper_t,
  _swigc__p_ext__shared_ptrT_SwapSpreadIndex_t,
  _swigc__p_ext__shared_ptrT_Swap_t,
  _swigc__p_ext__shared_ptrT_SwaptionHelper_t,
  _swigc__p_ext__shared_ptrT_SwaptionVolCube1_t,
  _swigc__p_ext__shared_ptrT_SwaptionVolCube2_t,
  _swigc__p_ext__shared_ptrT_SwaptionVolatilityCube_t,
  _swigc__p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t,
  _swigc__p_ext__shared_ptrT_SwaptionVolatilityMatrix_t,
  _swigc__p_ext__shared_ptrT_SwaptionVolatilityStructure_t,
  _swigc__p_ext__shared_ptrT_Swaption_t,
  _swigc__p_ext__shared_ptrT_SwingExercise_t,
  _swigc__p_ext__shared_ptrT_THBFIX_t,
  _swigc__p_ext__shared_ptrT_TRLibor_t,
  _swigc__p_ext__shared_ptrT_TermStructureConsistentModel_t,
  _swigc__p_ext__shared_ptrT_TermStructure_t,
  _swigc__p_ext__shared_ptrT_Tibor_t,
  _swigc__p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t,
  _swigc__p_ext__shared_ptrT_TreeCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_TreeSwaptionEngine_t,
  _swigc__p_ext__shared_ptrT_TripleBandLinearOp_t,
  _swigc__p_ext__shared_ptrT_TypePayoff_t,
  _swigc__p_ext__shared_ptrT_UKRPI_t,
  _swigc__p_ext__shared_ptrT_USCPI_t,
  _swigc__p_ext__shared_ptrT_USDLiborON_t,
  _swigc__p_ext__shared_ptrT_USDLibor_t,
  _swigc__p_ext__shared_ptrT_Uniform1dMesher_t,
  _swigc__p_ext__shared_ptrT_UpfrontCdsHelper_t,
  _swigc__p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t,
  _swigc__p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t,
  _swigc__p_ext__shared_ptrT_VanillaForwardPayoff_t,
  _swigc__p_ext__shared_ptrT_VanillaOption_t,
  _swigc__p_ext__shared_ptrT_VanillaSwap_t,
  _swigc__p_ext__shared_ptrT_VanillaSwingOption_t,
  _swigc__p_ext__shared_ptrT_VannaVolgaBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t,
  _swigc__p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_WulinYongDoubleBarrierEngine_t_t,
  _swigc__p_ext__shared_ptrT_VarianceGammaEngine_t,
  _swigc__p_ext__shared_ptrT_VarianceGammaProcess_t,
  _swigc__p_ext__shared_ptrT_Vasicek_t,
  _swigc__p_ext__shared_ptrT_VolatilityTermStructure_t,
  _swigc__p_ext__shared_ptrT_Wibor_t,
  _swigc__p_ext__shared_ptrT_WulinYongDoubleBarrierEngine_t,
  _swigc__p_ext__shared_ptrT_YYEUHICPXT_t,
  _swigc__p_ext__shared_ptrT_YYEUHICP_t,
  _swigc__p_ext__shared_ptrT_YYEUHICPr_t,
  _swigc__p_ext__shared_ptrT_YYFRHICP_t,
  _swigc__p_ext__shared_ptrT_YYFRHICPr_t,
  _swigc__p_ext__shared_ptrT_YYUKRPI_t,
  _swigc__p_ext__shared_ptrT_YYUKRPIr_t,
  _swigc__p_ext__shared_ptrT_YYUSCPI_t,
  _swigc__p_ext__shared_ptrT_YYUSCPIr_t,
  _swigc__p_ext__shared_ptrT_YYZACPI_t,
  _swigc__p_ext__shared_ptrT_YYZACPIr_t,
  _swigc__p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t,
  _swigc__p_ext__shared_ptrT_YearOnYearInflationSwap_t,
  _swigc__p_ext__shared_ptrT_YieldTermStructure_t,
  _swigc__p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t,
  _swigc__p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t,
  _swigc__p_ext__shared_ptrT_YoYInflationCapFloor_t,
  _swigc__p_ext__shared_ptrT_YoYInflationCap_t,
  _swigc__p_ext__shared_ptrT_YoYInflationCollar_t,
  _swigc__p_ext__shared_ptrT_YoYInflationFloor_t,
  _swigc__p_ext__shared_ptrT_YoYInflationIndex_t,
  _swigc__p_ext__shared_ptrT_YoYInflationTermStructure_t,
  _swigc__p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t,
  _swigc__p_ext__shared_ptrT_YoYOptionletHelper_t,
  _swigc__p_ext__shared_ptrT_YoYOptionletStripper_t,
  _swigc__p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t,
  _swigc__p_ext__shared_ptrT_ZACPI_t,
  _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t,
  _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t,
  _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t,
  _swigc__p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t,
  _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t,
  _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t,
  _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t,
  _swigc__p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t,
  _swigc__p_ext__shared_ptrT_ZeroCouponBond_t,
  _swigc__p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t,
  _swigc__p_ext__shared_ptrT_ZeroCouponInflationSwap_t,
  _swigc__p_ext__shared_ptrT_ZeroInflationIndex_t,
  _swigc__p_ext__shared_ptrT_ZeroInflationTermStructure_t,
  _swigc__p_ext__shared_ptrT_ZeroSpreadedTermStructure_t,
  _swigc__p_ext__shared_ptrT_Zibor_t,
  _swigc__p_ext__tupleT_double_double_bool_t,
  _swigc__p_ext__tupleT_double_double_double_t,
  _swigc__p_first_type,
  _swigc__p_int,
  _swigc__p_key_type,
  _swigc__p_long,
  _swigc__p_mapped_type,
  _swigc__p_p_PyObject,
  _swigc__p_sample_type,
  _swigc__p_second_type,
  _swigc__p_size_t,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_Date_t,
  _swigc__p_std__allocatorT_HandleT_Quote_t_t,
  _swigc__p_std__allocatorT_InterestRate_t,
  _swigc__p_std__allocatorT_IntervalPrice_t,
  _swigc__p_std__allocatorT_Period_t,
  _swigc__p_std__allocatorT_RelinkableHandleT_Quote_t_t,
  _swigc__p_std__allocatorT_bool_t,
  _swigc__p_std__allocatorT_double_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_Callability_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_Dividend_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_Instrument_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_Quote_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t,
  _swigc__p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t,
  _swigc__p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t,
  _swigc__p_std__allocatorT_int_t,
  _swigc__p_std__allocatorT_std__pairT_Date_double_t_t,
  _swigc__p_std__allocatorT_std__pairT_double_const_Date_t_t,
  _swigc__p_std__allocatorT_std__pairT_double_double_t_t,
  _swigc__p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t,
  _swigc__p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t,
  _swigc__p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t,
  _swigc__p_std__allocatorT_unsigned_int_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__lessT_double_t,
  _swigc__p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t,
  _swigc__p_std__pairT_Date_double_t,
  _swigc__p_std__pairT_double_double_t,
  _swigc__p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t,
  _swigc__p_std__pairT_size_t_size_t_t,
  _swigc__p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t,
  _swigc__p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t,
  _swigc__p_std__vectorT_Date_std__allocatorT_Date_t_t,
  _swigc__p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t,
  _swigc__p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t,
  _swigc__p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t,
  _swigc__p_std__vectorT_Period_std__allocatorT_Period_t_t,
  _swigc__p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t,
  _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t,
  _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t,
  _swigc__p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t,
  _swigc__p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t,
  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
  _swigc__p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t,
  _swigc__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,
  _swigc__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,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__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,
  _swigc__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,
  _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_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,
  _swigc__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_value_type,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        "swigvarlink",                      /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        0,                                  /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
        0,                                  /* tp_del */
        0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#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;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *globals = 0;
    if (!globals) {
      globals = SWIG_newvarlink();
    }
    return globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  PyDict_SetItemString(md, "cvar", globals);
  Py_DECREF(globals);
  SWIG_addvarlink(globals, "__hexversion__", Swig_var___hexversion___get, Swig_var___hexversion___set);
  SWIG_addvarlink(globals, "__version__", Swig_var___version___get, Swig_var___version___set);
  SWIG_Python_SetConstant(d, "SHARED_PTR_DISOWN",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "Sunday",SWIG_From_int(static_cast< int >(Sunday)));
  SWIG_Python_SetConstant(d, "Monday",SWIG_From_int(static_cast< int >(Monday)));
  SWIG_Python_SetConstant(d, "Tuesday",SWIG_From_int(static_cast< int >(Tuesday)));
  SWIG_Python_SetConstant(d, "Wednesday",SWIG_From_int(static_cast< int >(Wednesday)));
  SWIG_Python_SetConstant(d, "Thursday",SWIG_From_int(static_cast< int >(Thursday)));
  SWIG_Python_SetConstant(d, "Friday",SWIG_From_int(static_cast< int >(Friday)));
  SWIG_Python_SetConstant(d, "Saturday",SWIG_From_int(static_cast< int >(Saturday)));
  SWIG_Python_SetConstant(d, "January",SWIG_From_int(static_cast< int >(January)));
  SWIG_Python_SetConstant(d, "February",SWIG_From_int(static_cast< int >(February)));
  SWIG_Python_SetConstant(d, "March",SWIG_From_int(static_cast< int >(March)));
  SWIG_Python_SetConstant(d, "April",SWIG_From_int(static_cast< int >(April)));
  SWIG_Python_SetConstant(d, "May",SWIG_From_int(static_cast< int >(May)));
  SWIG_Python_SetConstant(d, "June",SWIG_From_int(static_cast< int >(June)));
  SWIG_Python_SetConstant(d, "July",SWIG_From_int(static_cast< int >(July)));
  SWIG_Python_SetConstant(d, "August",SWIG_From_int(static_cast< int >(August)));
  SWIG_Python_SetConstant(d, "September",SWIG_From_int(static_cast< int >(September)));
  SWIG_Python_SetConstant(d, "October",SWIG_From_int(static_cast< int >(October)));
  SWIG_Python_SetConstant(d, "November",SWIG_From_int(static_cast< int >(November)));
  SWIG_Python_SetConstant(d, "December",SWIG_From_int(static_cast< int >(December)));
  SWIG_Python_SetConstant(d, "Days",SWIG_From_int(static_cast< int >(Days)));
  SWIG_Python_SetConstant(d, "Weeks",SWIG_From_int(static_cast< int >(Weeks)));
  SWIG_Python_SetConstant(d, "Months",SWIG_From_int(static_cast< int >(Months)));
  SWIG_Python_SetConstant(d, "Years",SWIG_From_int(static_cast< int >(Years)));
  SWIG_Python_SetConstant(d, "Hours",SWIG_From_int(static_cast< int >(Hours)));
  SWIG_Python_SetConstant(d, "Minutes",SWIG_From_int(static_cast< int >(Minutes)));
  SWIG_Python_SetConstant(d, "Seconds",SWIG_From_int(static_cast< int >(Seconds)));
  SWIG_Python_SetConstant(d, "Milliseconds",SWIG_From_int(static_cast< int >(Milliseconds)));
  SWIG_Python_SetConstant(d, "Microseconds",SWIG_From_int(static_cast< int >(Microseconds)));
  SWIG_Python_SetConstant(d, "NoFrequency",SWIG_From_int(static_cast< int >(NoFrequency)));
  SWIG_Python_SetConstant(d, "Once",SWIG_From_int(static_cast< int >(Once)));
  SWIG_Python_SetConstant(d, "Annual",SWIG_From_int(static_cast< int >(Annual)));
  SWIG_Python_SetConstant(d, "Semiannual",SWIG_From_int(static_cast< int >(Semiannual)));
  SWIG_Python_SetConstant(d, "EveryFourthMonth",SWIG_From_int(static_cast< int >(EveryFourthMonth)));
  SWIG_Python_SetConstant(d, "Quarterly",SWIG_From_int(static_cast< int >(Quarterly)));
  SWIG_Python_SetConstant(d, "Bimonthly",SWIG_From_int(static_cast< int >(Bimonthly)));
  SWIG_Python_SetConstant(d, "Monthly",SWIG_From_int(static_cast< int >(Monthly)));
  SWIG_Python_SetConstant(d, "EveryFourthWeek",SWIG_From_int(static_cast< int >(EveryFourthWeek)));
  SWIG_Python_SetConstant(d, "Biweekly",SWIG_From_int(static_cast< int >(Biweekly)));
  SWIG_Python_SetConstant(d, "Weekly",SWIG_From_int(static_cast< int >(Weekly)));
  SWIG_Python_SetConstant(d, "Daily",SWIG_From_int(static_cast< int >(Daily)));
  SWIG_Python_SetConstant(d, "OtherFrequency",SWIG_From_int(static_cast< int >(OtherFrequency)));
  
  // thread safe initialization
  swig::container_owner_attribute();
  
  SWIG_Python_SetConstant(d, "IMM_F",SWIG_From_int(static_cast< int >(IMM::F)));
  SWIG_Python_SetConstant(d, "IMM_G",SWIG_From_int(static_cast< int >(IMM::G)));
  SWIG_Python_SetConstant(d, "IMM_H",SWIG_From_int(static_cast< int >(IMM::H)));
  SWIG_Python_SetConstant(d, "IMM_J",SWIG_From_int(static_cast< int >(IMM::J)));
  SWIG_Python_SetConstant(d, "IMM_K",SWIG_From_int(static_cast< int >(IMM::K)));
  SWIG_Python_SetConstant(d, "IMM_M",SWIG_From_int(static_cast< int >(IMM::M)));
  SWIG_Python_SetConstant(d, "IMM_N",SWIG_From_int(static_cast< int >(IMM::N)));
  SWIG_Python_SetConstant(d, "IMM_Q",SWIG_From_int(static_cast< int >(IMM::Q)));
  SWIG_Python_SetConstant(d, "IMM_U",SWIG_From_int(static_cast< int >(IMM::U)));
  SWIG_Python_SetConstant(d, "IMM_V",SWIG_From_int(static_cast< int >(IMM::V)));
  SWIG_Python_SetConstant(d, "IMM_X",SWIG_From_int(static_cast< int >(IMM::X)));
  SWIG_Python_SetConstant(d, "IMM_Z",SWIG_From_int(static_cast< int >(IMM::Z)));
  SWIG_Python_SetConstant(d, "ASX_F",SWIG_From_int(static_cast< int >(ASX::F)));
  SWIG_Python_SetConstant(d, "ASX_G",SWIG_From_int(static_cast< int >(ASX::G)));
  SWIG_Python_SetConstant(d, "ASX_H",SWIG_From_int(static_cast< int >(ASX::H)));
  SWIG_Python_SetConstant(d, "ASX_J",SWIG_From_int(static_cast< int >(ASX::J)));
  SWIG_Python_SetConstant(d, "ASX_K",SWIG_From_int(static_cast< int >(ASX::K)));
  SWIG_Python_SetConstant(d, "ASX_M",SWIG_From_int(static_cast< int >(ASX::M)));
  SWIG_Python_SetConstant(d, "ASX_N",SWIG_From_int(static_cast< int >(ASX::N)));
  SWIG_Python_SetConstant(d, "ASX_Q",SWIG_From_int(static_cast< int >(ASX::Q)));
  SWIG_Python_SetConstant(d, "ASX_U",SWIG_From_int(static_cast< int >(ASX::U)));
  SWIG_Python_SetConstant(d, "ASX_V",SWIG_From_int(static_cast< int >(ASX::V)));
  SWIG_Python_SetConstant(d, "ASX_X",SWIG_From_int(static_cast< int >(ASX::X)));
  SWIG_Python_SetConstant(d, "ASX_Z",SWIG_From_int(static_cast< int >(ASX::Z)));
  SWIG_Python_SetConstant(d, "Exercise_American",SWIG_From_int(static_cast< int >(Exercise::American)));
  SWIG_Python_SetConstant(d, "Exercise_Bermudan",SWIG_From_int(static_cast< int >(Exercise::Bermudan)));
  SWIG_Python_SetConstant(d, "Exercise_European",SWIG_From_int(static_cast< int >(Exercise::European)));
  SWIG_Python_SetConstant(d, "SalvagingAlgorithm_NoAlgorithm",SWIG_From_int(static_cast< int >(SalvagingAlgorithm::None)));
  SWIG_Python_SetConstant(d, "SalvagingAlgorithm_Spectral",SWIG_From_int(static_cast< int >(SalvagingAlgorithm::Spectral)));
  SWIG_Python_SetConstant(d, "Following",SWIG_From_int(static_cast< int >(Following)));
  SWIG_Python_SetConstant(d, "ModifiedFollowing",SWIG_From_int(static_cast< int >(ModifiedFollowing)));
  SWIG_Python_SetConstant(d, "Preceding",SWIG_From_int(static_cast< int >(Preceding)));
  SWIG_Python_SetConstant(d, "ModifiedPreceding",SWIG_From_int(static_cast< int >(ModifiedPreceding)));
  SWIG_Python_SetConstant(d, "Unadjusted",SWIG_From_int(static_cast< int >(Unadjusted)));
  SWIG_Python_SetConstant(d, "HalfMonthModifiedFollowing",SWIG_From_int(static_cast< int >(HalfMonthModifiedFollowing)));
  SWIG_Python_SetConstant(d, "JoinHolidays",SWIG_From_int(static_cast< int >(JoinHolidays)));
  SWIG_Python_SetConstant(d, "JoinBusinessDays",SWIG_From_int(static_cast< int >(JoinBusinessDays)));
  SWIG_Python_SetConstant(d, "Argentina_Merval",SWIG_From_int(static_cast< int >(QuantLib::Argentina::Merval)));
  SWIG_Python_SetConstant(d, "Brazil_Settlement",SWIG_From_int(static_cast< int >(QuantLib::Brazil::Settlement)));
  SWIG_Python_SetConstant(d, "Brazil_Exchange",SWIG_From_int(static_cast< int >(QuantLib::Brazil::Exchange)));
  SWIG_Python_SetConstant(d, "Canada_Settlement",SWIG_From_int(static_cast< int >(QuantLib::Canada::Settlement)));
  SWIG_Python_SetConstant(d, "Canada_TSX",SWIG_From_int(static_cast< int >(QuantLib::Canada::TSX)));
  SWIG_Python_SetConstant(d, "China_SSE",SWIG_From_int(static_cast< int >(QuantLib::China::SSE)));
  SWIG_Python_SetConstant(d, "China_IB",SWIG_From_int(static_cast< int >(QuantLib::China::IB)));
  SWIG_Python_SetConstant(d, "CzechRepublic_PSE",SWIG_From_int(static_cast< int >(QuantLib::CzechRepublic::PSE)));
  SWIG_Python_SetConstant(d, "France_Settlement",SWIG_From_int(static_cast< int >(QuantLib::France::Settlement)));
  SWIG_Python_SetConstant(d, "France_Exchange",SWIG_From_int(static_cast< int >(QuantLib::France::Exchange)));
  SWIG_Python_SetConstant(d, "Germany_Settlement",SWIG_From_int(static_cast< int >(QuantLib::Germany::Settlement)));
  SWIG_Python_SetConstant(d, "Germany_FrankfurtStockExchange",SWIG_From_int(static_cast< int >(QuantLib::Germany::FrankfurtStockExchange)));
  SWIG_Python_SetConstant(d, "Germany_Xetra",SWIG_From_int(static_cast< int >(QuantLib::Germany::Xetra)));
  SWIG_Python_SetConstant(d, "Germany_Eurex",SWIG_From_int(static_cast< int >(QuantLib::Germany::Eurex)));
  SWIG_Python_SetConstant(d, "HongKong_HKEx",SWIG_From_int(static_cast< int >(QuantLib::HongKong::HKEx)));
  SWIG_Python_SetConstant(d, "Iceland_ICEX",SWIG_From_int(static_cast< int >(QuantLib::Iceland::ICEX)));
  SWIG_Python_SetConstant(d, "India_NSE",SWIG_From_int(static_cast< int >(QuantLib::India::NSE)));
  SWIG_Python_SetConstant(d, "Indonesia_BEJ",SWIG_From_int(static_cast< int >(QuantLib::Indonesia::BEJ)));
  SWIG_Python_SetConstant(d, "Indonesia_JSX",SWIG_From_int(static_cast< int >(QuantLib::Indonesia::JSX)));
  SWIG_Python_SetConstant(d, "Israel_Settlement",SWIG_From_int(static_cast< int >(QuantLib::Israel::Settlement)));
  SWIG_Python_SetConstant(d, "Israel_TASE",SWIG_From_int(static_cast< int >(QuantLib::Israel::TASE)));
  SWIG_Python_SetConstant(d, "Italy_Settlement",SWIG_From_int(static_cast< int >(QuantLib::Italy::Settlement)));
  SWIG_Python_SetConstant(d, "Italy_Exchange",SWIG_From_int(static_cast< int >(QuantLib::Italy::Exchange)));
  SWIG_Python_SetConstant(d, "Mexico_BMV",SWIG_From_int(static_cast< int >(QuantLib::Mexico::BMV)));
  SWIG_Python_SetConstant(d, "Russia_Settlement",SWIG_From_int(static_cast< int >(QuantLib::Russia::Settlement)));
  SWIG_Python_SetConstant(d, "Russia_MOEX",SWIG_From_int(static_cast< int >(QuantLib::Russia::MOEX)));
  SWIG_Python_SetConstant(d, "SaudiArabia_Tadawul",SWIG_From_int(static_cast< int >(QuantLib::SaudiArabia::Tadawul)));
  SWIG_Python_SetConstant(d, "Singapore_SGX",SWIG_From_int(static_cast< int >(QuantLib::Singapore::SGX)));
  SWIG_Python_SetConstant(d, "Slovakia_BSSE",SWIG_From_int(static_cast< int >(QuantLib::Slovakia::BSSE)));
  SWIG_Python_SetConstant(d, "SouthKorea_Settlement",SWIG_From_int(static_cast< int >(QuantLib::SouthKorea::Settlement)));
  SWIG_Python_SetConstant(d, "SouthKorea_KRX",SWIG_From_int(static_cast< int >(QuantLib::SouthKorea::KRX)));
  SWIG_Python_SetConstant(d, "Taiwan_TSEC",SWIG_From_int(static_cast< int >(QuantLib::Taiwan::TSEC)));
  SWIG_Python_SetConstant(d, "Ukraine_USE",SWIG_From_int(static_cast< int >(QuantLib::Ukraine::USE)));
  SWIG_Python_SetConstant(d, "UnitedKingdom_Settlement",SWIG_From_int(static_cast< int >(QuantLib::UnitedKingdom::Settlement)));
  SWIG_Python_SetConstant(d, "UnitedKingdom_Exchange",SWIG_From_int(static_cast< int >(QuantLib::UnitedKingdom::Exchange)));
  SWIG_Python_SetConstant(d, "UnitedKingdom_Metals",SWIG_From_int(static_cast< int >(QuantLib::UnitedKingdom::Metals)));
  SWIG_Python_SetConstant(d, "UnitedStates_Settlement",SWIG_From_int(static_cast< int >(QuantLib::UnitedStates::Settlement)));
  SWIG_Python_SetConstant(d, "UnitedStates_NYSE",SWIG_From_int(static_cast< int >(QuantLib::UnitedStates::NYSE)));
  SWIG_Python_SetConstant(d, "UnitedStates_GovernmentBond",SWIG_From_int(static_cast< int >(QuantLib::UnitedStates::GovernmentBond)));
  SWIG_Python_SetConstant(d, "UnitedStates_NERC",SWIG_From_int(static_cast< int >(QuantLib::UnitedStates::NERC)));
  SWIG_Python_SetConstant(d, "UnitedStates_LiborImpact",SWIG_From_int(static_cast< int >(QuantLib::UnitedStates::LiborImpact)));
  SWIG_Python_SetConstant(d, "UnitedStates_FederalReserve",SWIG_From_int(static_cast< int >(QuantLib::UnitedStates::FederalReserve)));
  SWIG_Python_SetConstant(d, "Actual365Fixed_Standard",SWIG_From_int(static_cast< int >(QuantLib::Actual365Fixed::Standard)));
  SWIG_Python_SetConstant(d, "Actual365Fixed_Canadian",SWIG_From_int(static_cast< int >(QuantLib::Actual365Fixed::Canadian)));
  SWIG_Python_SetConstant(d, "Actual365Fixed_NoLeap",SWIG_From_int(static_cast< int >(QuantLib::Actual365Fixed::NoLeap)));
  SWIG_Python_SetConstant(d, "Thirty360_USA",SWIG_From_int(static_cast< int >(QuantLib::Thirty360::USA)));
  SWIG_Python_SetConstant(d, "Thirty360_BondBasis",SWIG_From_int(static_cast< int >(QuantLib::Thirty360::BondBasis)));
  SWIG_Python_SetConstant(d, "Thirty360_European",SWIG_From_int(static_cast< int >(QuantLib::Thirty360::European)));
  SWIG_Python_SetConstant(d, "Thirty360_EurobondBasis",SWIG_From_int(static_cast< int >(QuantLib::Thirty360::EurobondBasis)));
  SWIG_Python_SetConstant(d, "Thirty360_Italian",SWIG_From_int(static_cast< int >(QuantLib::Thirty360::Italian)));
  SWIG_Python_SetConstant(d, "ActualActual_ISMA",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::ISMA)));
  SWIG_Python_SetConstant(d, "ActualActual_Bond",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::Bond)));
  SWIG_Python_SetConstant(d, "ActualActual_ISDA",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::ISDA)));
  SWIG_Python_SetConstant(d, "ActualActual_Historical",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::Historical)));
  SWIG_Python_SetConstant(d, "ActualActual_Actual365",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::Actual365)));
  SWIG_Python_SetConstant(d, "ActualActual_AFB",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::AFB)));
  SWIG_Python_SetConstant(d, "ActualActual_Euro",SWIG_From_int(static_cast< int >(QuantLib::ActualActual::Euro)));
  SWIG_Python_SetConstant(d, "Simple",SWIG_From_int(static_cast< int >(Simple)));
  SWIG_Python_SetConstant(d, "Compounded",SWIG_From_int(static_cast< int >(Compounded)));
  SWIG_Python_SetConstant(d, "Continuous",SWIG_From_int(static_cast< int >(Continuous)));
  SWIG_Python_SetConstant(d, "SimpleThenCompounded",SWIG_From_int(static_cast< int >(SimpleThenCompounded)));
  SWIG_Python_SetConstant(d, "CompoundedThenSimple",SWIG_From_int(static_cast< int >(CompoundedThenSimple)));
  SWIG_Python_SetConstant(d, "EndCriteria_NoCriteria",SWIG_From_int(static_cast< int >(EndCriteria::None)));
  SWIG_Python_SetConstant(d, "EndCriteria_MaxIterations",SWIG_From_int(static_cast< int >(EndCriteria::MaxIterations)));
  SWIG_Python_SetConstant(d, "EndCriteria_StationaryPoint",SWIG_From_int(static_cast< int >(EndCriteria::StationaryPoint)));
  SWIG_Python_SetConstant(d, "EndCriteria_StationaryFunctionValue",SWIG_From_int(static_cast< int >(EndCriteria::StationaryFunctionValue)));
  SWIG_Python_SetConstant(d, "EndCriteria_StationaryFunctionAccuracy",SWIG_From_int(static_cast< int >(EndCriteria::StationaryFunctionAccuracy)));
  SWIG_Python_SetConstant(d, "EndCriteria_ZeroGradientNorm",SWIG_From_int(static_cast< int >(EndCriteria::ZeroGradientNorm)));
  SWIG_Python_SetConstant(d, "EndCriteria_Unknown",SWIG_From_int(static_cast< int >(EndCriteria::Unknown)));
  SWIG_Python_SetConstant(d, "GaussianSimulatedAnnealing_NoResetScheme",SWIG_From_int(static_cast< int >(GaussianSimulatedAnnealing::NoResetScheme)));
  SWIG_Python_SetConstant(d, "GaussianSimulatedAnnealing_ResetToBestPoint",SWIG_From_int(static_cast< int >(GaussianSimulatedAnnealing::ResetToBestPoint)));
  SWIG_Python_SetConstant(d, "GaussianSimulatedAnnealing_ResetToOrigin",SWIG_From_int(static_cast< int >(GaussianSimulatedAnnealing::ResetToOrigin)));
  SWIG_Python_SetConstant(d, "MirrorGaussianSimulatedAnnealing_NoResetScheme",SWIG_From_int(static_cast< int >(MirrorGaussianSimulatedAnnealing::NoResetScheme)));
  SWIG_Python_SetConstant(d, "MirrorGaussianSimulatedAnnealing_ResetToBestPoint",SWIG_From_int(static_cast< int >(MirrorGaussianSimulatedAnnealing::ResetToBestPoint)));
  SWIG_Python_SetConstant(d, "MirrorGaussianSimulatedAnnealing_ResetToOrigin",SWIG_From_int(static_cast< int >(MirrorGaussianSimulatedAnnealing::ResetToOrigin)));
  SWIG_Python_SetConstant(d, "LogNormalSimulatedAnnealing_NoResetScheme",SWIG_From_int(static_cast< int >(LogNormalSimulatedAnnealing::NoResetScheme)));
  SWIG_Python_SetConstant(d, "LogNormalSimulatedAnnealing_ResetToBestPoint",SWIG_From_int(static_cast< int >(LogNormalSimulatedAnnealing::ResetToBestPoint)));
  SWIG_Python_SetConstant(d, "LogNormalSimulatedAnnealing_ResetToOrigin",SWIG_From_int(static_cast< int >(LogNormalSimulatedAnnealing::ResetToOrigin)));
  SWIG_Python_SetConstant(d, "IntervalPrice_Open",SWIG_From_int(static_cast< int >(IntervalPrice::Open)));
  SWIG_Python_SetConstant(d, "IntervalPrice_Close",SWIG_From_int(static_cast< int >(IntervalPrice::Close)));
  SWIG_Python_SetConstant(d, "IntervalPrice_High",SWIG_From_int(static_cast< int >(IntervalPrice::High)));
  SWIG_Python_SetConstant(d, "IntervalPrice_Low",SWIG_From_int(static_cast< int >(IntervalPrice::Low)));
  SWIG_Python_SetConstant(d, "ShiftedLognormal",SWIG_From_int(static_cast< int >(ShiftedLognormal)));
  SWIG_Python_SetConstant(d, "Normal",SWIG_From_int(static_cast< int >(Normal)));
  SWIG_Python_SetConstant(d, "BlackVarianceSurface_ConstantExtrapolation",SWIG_From_int(static_cast< int >(BlackVarianceSurface::ConstantExtrapolation)));
  SWIG_Python_SetConstant(d, "BlackVarianceSurface_InterpolatorDefaultExtrapolation",SWIG_From_int(static_cast< int >(BlackVarianceSurface::InterpolatorDefaultExtrapolation)));
  SWIG_Python_SetConstant(d, "AndreasenHugeVolatilityInterpl_PiecewiseConstant",SWIG_From_int(static_cast< int >(AndreasenHugeVolatilityInterpl::PiecewiseConstant)));
  SWIG_Python_SetConstant(d, "AndreasenHugeVolatilityInterpl_Linear",SWIG_From_int(static_cast< int >(AndreasenHugeVolatilityInterpl::Linear)));
  SWIG_Python_SetConstant(d, "AndreasenHugeVolatilityInterpl_CubicSpline",SWIG_From_int(static_cast< int >(AndreasenHugeVolatilityInterpl::CubicSpline)));
  SWIG_Python_SetConstant(d, "AndreasenHugeVolatilityInterpl_Call",SWIG_From_int(static_cast< int >(AndreasenHugeVolatilityInterpl::Call)));
  SWIG_Python_SetConstant(d, "AndreasenHugeVolatilityInterpl_Put",SWIG_From_int(static_cast< int >(AndreasenHugeVolatilityInterpl::Put)));
  SWIG_Python_SetConstant(d, "AndreasenHugeVolatilityInterpl_CallPut",SWIG_From_int(static_cast< int >(AndreasenHugeVolatilityInterpl::CallPut)));
  SWIG_Python_SetConstant(d, "CmsMarketCalibration_OnSpread",SWIG_From_int(static_cast< int >(CmsMarketCalibration::OnSpread)));
  SWIG_Python_SetConstant(d, "CmsMarketCalibration_OnPrice",SWIG_From_int(static_cast< int >(CmsMarketCalibration::OnPrice)));
  SWIG_Python_SetConstant(d, "CmsMarketCalibration_OnForwardCmsPrice",SWIG_From_int(static_cast< int >(CmsMarketCalibration::OnForwardCmsPrice)));
  SWIG_Python_SetConstant(d, "HestonProcess_PartialTruncation",SWIG_From_int(static_cast< int >(HestonProcess::PartialTruncation)));
  SWIG_Python_SetConstant(d, "HestonProcess_FullTruncation",SWIG_From_int(static_cast< int >(HestonProcess::FullTruncation)));
  SWIG_Python_SetConstant(d, "HestonProcess_Reflection",SWIG_From_int(static_cast< int >(HestonProcess::Reflection)));
  SWIG_Python_SetConstant(d, "HestonProcess_NonCentralChiSquareVariance",SWIG_From_int(static_cast< int >(HestonProcess::NonCentralChiSquareVariance)));
  SWIG_Python_SetConstant(d, "HestonProcess_QuadraticExponential",SWIG_From_int(static_cast< int >(HestonProcess::QuadraticExponential)));
  SWIG_Python_SetConstant(d, "HestonProcess_QuadraticExponentialMartingale",SWIG_From_int(static_cast< int >(HestonProcess::QuadraticExponentialMartingale)));
  SWIG_Python_SetConstant(d, "HestonProcess_BroadieKayaExactSchemeLobatto",SWIG_From_int(static_cast< int >(HestonProcess::BroadieKayaExactSchemeLobatto)));
  SWIG_Python_SetConstant(d, "HestonProcess_BroadieKayaExactSchemeLaguerre",SWIG_From_int(static_cast< int >(HestonProcess::BroadieKayaExactSchemeLaguerre)));
  SWIG_Python_SetConstant(d, "HestonProcess_BroadieKayaExactSchemeTrapezoidal",SWIG_From_int(static_cast< int >(HestonProcess::BroadieKayaExactSchemeTrapezoidal)));
  SWIG_Python_SetConstant(d, "ExtendedOrnsteinUhlenbeckProcess_MidPoint",SWIG_From_int(static_cast< int >(ExtendedOrnsteinUhlenbeckProcess::MidPoint)));
  SWIG_Python_SetConstant(d, "ExtendedOrnsteinUhlenbeckProcess_Trapezodial",SWIG_From_int(static_cast< int >(ExtendedOrnsteinUhlenbeckProcess::Trapezodial)));
  SWIG_Python_SetConstant(d, "ExtendedOrnsteinUhlenbeckProcess_GaussLobatto",SWIG_From_int(static_cast< int >(ExtendedOrnsteinUhlenbeckProcess::GaussLobatto)));
  SWIG_Python_SetConstant(d, "GJRGARCHProcess_PartialTruncation",SWIG_From_int(static_cast< int >(GJRGARCHProcess::PartialTruncation)));
  SWIG_Python_SetConstant(d, "GJRGARCHProcess_FullTruncation",SWIG_From_int(static_cast< int >(GJRGARCHProcess::FullTruncation)));
  SWIG_Python_SetConstant(d, "GJRGARCHProcess_Reflection",SWIG_From_int(static_cast< int >(GJRGARCHProcess::Reflection)));
  SWIG_Python_SetConstant(d, "DateGeneration_Backward",SWIG_From_int(static_cast< int >(DateGeneration::Backward)));
  SWIG_Python_SetConstant(d, "DateGeneration_Forward",SWIG_From_int(static_cast< int >(DateGeneration::Forward)));
  SWIG_Python_SetConstant(d, "DateGeneration_Zero",SWIG_From_int(static_cast< int >(DateGeneration::Zero)));
  SWIG_Python_SetConstant(d, "DateGeneration_ThirdWednesday",SWIG_From_int(static_cast< int >(DateGeneration::ThirdWednesday)));
  SWIG_Python_SetConstant(d, "DateGeneration_Twentieth",SWIG_From_int(static_cast< int >(DateGeneration::Twentieth)));
  SWIG_Python_SetConstant(d, "DateGeneration_TwentiethIMM",SWIG_From_int(static_cast< int >(DateGeneration::TwentiethIMM)));
  SWIG_Python_SetConstant(d, "DateGeneration_OldCDS",SWIG_From_int(static_cast< int >(DateGeneration::OldCDS)));
  SWIG_Python_SetConstant(d, "DateGeneration_CDS",SWIG_From_int(static_cast< int >(DateGeneration::CDS)));
  SWIG_Python_SetConstant(d, "DateGeneration_CDS2015",SWIG_From_int(static_cast< int >(DateGeneration::CDS2015)));
  SWIG_Python_SetConstant(d, "BlackIborCouponPricer_Black76",SWIG_From_int(static_cast< int >(BlackIborCouponPricer::Black76)));
  SWIG_Python_SetConstant(d, "BlackIborCouponPricer_BivariateLognormal",SWIG_From_int(static_cast< int >(BlackIborCouponPricer::BivariateLognormal)));
  SWIG_Python_SetConstant(d, "GFunctionFactory_Standard",SWIG_From_int(static_cast< int >(GFunctionFactory::Standard)));
  SWIG_Python_SetConstant(d, "GFunctionFactory_ExactYield",SWIG_From_int(static_cast< int >(GFunctionFactory::ExactYield)));
  SWIG_Python_SetConstant(d, "GFunctionFactory_ParallelShifts",SWIG_From_int(static_cast< int >(GFunctionFactory::ParallelShifts)));
  SWIG_Python_SetConstant(d, "GFunctionFactory_NonParallelShifts",SWIG_From_int(static_cast< int >(GFunctionFactory::NonParallelShifts)));
  SWIG_Python_SetConstant(d, "LinearTsrPricerSettings_RateBound",SWIG_From_int(static_cast< int >(LinearTsrPricer::Settings::RateBound)));
  SWIG_Python_SetConstant(d, "LinearTsrPricerSettings_VegaRatio",SWIG_From_int(static_cast< int >(LinearTsrPricer::Settings::VegaRatio)));
  SWIG_Python_SetConstant(d, "LinearTsrPricerSettings_PriceThreshold",SWIG_From_int(static_cast< int >(LinearTsrPricer::Settings::PriceThreshold)));
  SWIG_Python_SetConstant(d, "LinearTsrPricerSettings_BSStdDevs",SWIG_From_int(static_cast< int >(LinearTsrPricer::Settings::BSStdDevs)));
  SWIG_Python_SetConstant(d, "Duration_Simple",SWIG_From_int(static_cast< int >(Duration::Simple)));
  SWIG_Python_SetConstant(d, "Duration_Macaulay",SWIG_From_int(static_cast< int >(Duration::Macaulay)));
  SWIG_Python_SetConstant(d, "Duration_Modified",SWIG_From_int(static_cast< int >(Duration::Modified)));
  SWIG_Python_SetConstant(d, "BlackCalibrationHelper_RelativePriceError",SWIG_From_int(static_cast< int >(BlackCalibrationHelper::RelativePriceError)));
  SWIG_Python_SetConstant(d, "BlackCalibrationHelper_PriceError",SWIG_From_int(static_cast< int >(BlackCalibrationHelper::PriceError)));
  SWIG_Python_SetConstant(d, "BlackCalibrationHelper_ImpliedVolError",SWIG_From_int(static_cast< int >(BlackCalibrationHelper::ImpliedVolError)));
  SWIG_Python_SetConstant(d, "Option_Put",SWIG_From_int(static_cast< int >(Option::Put)));
  SWIG_Python_SetConstant(d, "Option_Call",SWIG_From_int(static_cast< int >(Option::Call)));
  SWIG_Python_SetConstant(d, "Barrier_DownIn",SWIG_From_int(static_cast< int >(Barrier::DownIn)));
  SWIG_Python_SetConstant(d, "Barrier_UpIn",SWIG_From_int(static_cast< int >(Barrier::UpIn)));
  SWIG_Python_SetConstant(d, "Barrier_DownOut",SWIG_From_int(static_cast< int >(Barrier::DownOut)));
  SWIG_Python_SetConstant(d, "Barrier_UpOut",SWIG_From_int(static_cast< int >(Barrier::UpOut)));
  SWIG_Python_SetConstant(d, "DoubleBarrier_KnockIn",SWIG_From_int(static_cast< int >(DoubleBarrier::KnockIn)));
  SWIG_Python_SetConstant(d, "DoubleBarrier_KnockOut",SWIG_From_int(static_cast< int >(DoubleBarrier::KnockOut)));
  SWIG_Python_SetConstant(d, "DoubleBarrier_KIKO",SWIG_From_int(static_cast< int >(DoubleBarrier::KIKO)));
  SWIG_Python_SetConstant(d, "DoubleBarrier_KOKI",SWIG_From_int(static_cast< int >(DoubleBarrier::KOKI)));
  SWIG_Python_SetConstant(d, "AnalyticHestonEngine_Gatheral",SWIG_From_int(static_cast< int >(AnalyticHestonEngine::Gatheral)));
  SWIG_Python_SetConstant(d, "AnalyticHestonEngine_BranchCorrection",SWIG_From_int(static_cast< int >(AnalyticHestonEngine::BranchCorrection)));
  SWIG_Python_SetConstant(d, "AnalyticHestonEngine_AndersenPiterbarg",SWIG_From_int(static_cast< int >(AnalyticHestonEngine::AndersenPiterbarg)));
  SWIG_Python_SetConstant(d, "AnalyticHestonEngine_AndersenPiterbargOptCV",SWIG_From_int(static_cast< int >(AnalyticHestonEngine::AndersenPiterbargOptCV)));
  SWIG_Python_SetConstant(d, "AnalyticHestonEngine_AsymptoticChF",SWIG_From_int(static_cast< int >(AnalyticHestonEngine::AsymptoticChF)));
  SWIG_Python_SetConstant(d, "AnalyticHestonEngine_OptimalCV",SWIG_From_int(static_cast< int >(AnalyticHestonEngine::OptimalCV)));
  SWIG_Python_SetConstant(d, "ExponentialFittingHestonEngine_AndersenPiterbarg",SWIG_From_int(static_cast< int >(ExponentialFittingHestonEngine::AndersenPiterbarg)));
  SWIG_Python_SetConstant(d, "ExponentialFittingHestonEngine_AndersenPiterbargOptCV",SWIG_From_int(static_cast< int >(ExponentialFittingHestonEngine::AndersenPiterbargOptCV)));
  SWIG_Python_SetConstant(d, "ExponentialFittingHestonEngine_AsymptoticChF",SWIG_From_int(static_cast< int >(ExponentialFittingHestonEngine::AsymptoticChF)));
  SWIG_Python_SetConstant(d, "ExponentialFittingHestonEngine_OptimalCV",SWIG_From_int(static_cast< int >(ExponentialFittingHestonEngine::OptimalCV)));
  SWIG_Python_SetConstant(d, "AnalyticPTDHestonEngine_Gatheral",SWIG_From_int(static_cast< int >(AnalyticPTDHestonEngine::Gatheral)));
  SWIG_Python_SetConstant(d, "AnalyticPTDHestonEngine_AndersenPiterbarg",SWIG_From_int(static_cast< int >(AnalyticPTDHestonEngine::AndersenPiterbarg)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Monomial",SWIG_From_int(static_cast< int >(LsmBasisSystem::Monomial)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Laguerre",SWIG_From_int(static_cast< int >(LsmBasisSystem::Laguerre)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Hermite",SWIG_From_int(static_cast< int >(LsmBasisSystem::Hermite)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Hyperbolic",SWIG_From_int(static_cast< int >(LsmBasisSystem::Hyperbolic)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Legendre",SWIG_From_int(static_cast< int >(LsmBasisSystem::Legendre)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Chebyshev",SWIG_From_int(static_cast< int >(LsmBasisSystem::Chebyshev)));
  SWIG_Python_SetConstant(d, "LsmBasisSystem_Chebyshev2nd",SWIG_From_int(static_cast< int >(LsmBasisSystem::Chebyshev2nd)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_HundsdorferType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::HundsdorferType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_DouglasType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::DouglasType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_CraigSneydType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::CraigSneydType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_ModifiedCraigSneydType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::ModifiedCraigSneydType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_ImplicitEulerType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::ImplicitEulerType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_ExplicitEulerType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::ExplicitEulerType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_MethodOfLinesType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::MethodOfLinesType)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_TrBDF2Type",SWIG_From_int(static_cast< int >(FdmSchemeDesc::TrBDF2Type)));
  SWIG_Python_SetConstant(d, "FdmSchemeDesc_CrankNicolsonType",SWIG_From_int(static_cast< int >(FdmSchemeDesc::CrankNicolsonType)));
  SWIG_Python_SetConstant(d, "FdBlackScholesVanillaEngine_Spot",SWIG_From_int(static_cast< int >(FdBlackScholesVanillaEngine::Spot)));
  SWIG_Python_SetConstant(d, "FdBlackScholesVanillaEngine_Escrowed",SWIG_From_int(static_cast< int >(FdBlackScholesVanillaEngine::Escrowed)));
  SWIG_Python_SetConstant(d, "Average_Arithmetic",SWIG_From_int(static_cast< int >(Average::Arithmetic)));
  SWIG_Python_SetConstant(d, "Average_Geometric",SWIG_From_int(static_cast< int >(Average::Geometric)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_Spot",SWIG_From_int(static_cast< int >(DeltaVolQuote::Spot)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_Fwd",SWIG_From_int(static_cast< int >(DeltaVolQuote::Fwd)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_PaSpot",SWIG_From_int(static_cast< int >(DeltaVolQuote::PaSpot)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_PaFwd",SWIG_From_int(static_cast< int >(DeltaVolQuote::PaFwd)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmNull",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmNull)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmSpot",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmSpot)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmFwd",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmFwd)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmDeltaNeutral",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmDeltaNeutral)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmVegaMax",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmVegaMax)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmGammaMax",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmGammaMax)));
  SWIG_Python_SetConstant(d, "DeltaVolQuote_AtmPutCall50",SWIG_From_int(static_cast< int >(DeltaVolQuote::AtmPutCall50)));
  SWIG_Python_SetConstant(d, "CallabilityPrice_Dirty",SWIG_From_int(static_cast< int >(CallabilityPrice::Dirty)));
  SWIG_Python_SetConstant(d, "CallabilityPrice_Clean",SWIG_From_int(static_cast< int >(CallabilityPrice::Clean)));
  SWIG_Python_SetConstant(d, "Callability_Call",SWIG_From_int(static_cast< int >(Callability::Call)));
  SWIG_Python_SetConstant(d, "Callability_Put",SWIG_From_int(static_cast< int >(Callability::Put)));
  SWIG_Python_SetConstant(d, "VanillaSwap_Receiver",SWIG_From_int(static_cast< int >(VanillaSwap::Receiver)));
  SWIG_Python_SetConstant(d, "VanillaSwap_Payer",SWIG_From_int(static_cast< int >(VanillaSwap::Payer)));
  SWIG_Python_SetConstant(d, "OvernightIndexedSwap_Receiver",SWIG_From_int(static_cast< int >(OvernightIndexedSwap::Receiver)));
  SWIG_Python_SetConstant(d, "OvernightIndexedSwap_Payer",SWIG_From_int(static_cast< int >(OvernightIndexedSwap::Payer)));
  SWIG_Python_SetConstant(d, "CPI_AsIndex",SWIG_From_int(static_cast< int >(CPI::AsIndex)));
  SWIG_Python_SetConstant(d, "CPI_Flat",SWIG_From_int(static_cast< int >(CPI::Flat)));
  SWIG_Python_SetConstant(d, "CPI_Linear",SWIG_From_int(static_cast< int >(CPI::Linear)));
  SWIG_Python_SetConstant(d, "ZeroCouponInflationSwap_Receiver",SWIG_From_int(static_cast< int >(ZeroCouponInflationSwap::Receiver)));
  SWIG_Python_SetConstant(d, "ZeroCouponInflationSwap_Payer",SWIG_From_int(static_cast< int >(ZeroCouponInflationSwap::Payer)));
  SWIG_Python_SetConstant(d, "YearOnYearInflationSwap_Receiver",SWIG_From_int(static_cast< int >(YearOnYearInflationSwap::Receiver)));
  SWIG_Python_SetConstant(d, "YearOnYearInflationSwap_Payer",SWIG_From_int(static_cast< int >(YearOnYearInflationSwap::Payer)));
  SWIG_Python_SetConstant(d, "CPISwap_Receiver",SWIG_From_int(static_cast< int >(CPISwap::Receiver)));
  SWIG_Python_SetConstant(d, "CPISwap_Payer",SWIG_From_int(static_cast< int >(CPISwap::Payer)));
  SWIG_Python_SetConstant(d, "YoYInflationCapFloor_Cap",SWIG_From_int(static_cast< int >(YoYInflationCapFloor::Cap)));
  SWIG_Python_SetConstant(d, "YoYInflationCapFloor_Floor",SWIG_From_int(static_cast< int >(YoYInflationCapFloor::Floor)));
  SWIG_Python_SetConstant(d, "YoYInflationCapFloor_Collar",SWIG_From_int(static_cast< int >(YoYInflationCapFloor::Collar)));
  SWIG_Python_SetConstant(d, "CapFloor_Cap",SWIG_From_int(static_cast< int >(CapFloor::Cap)));
  SWIG_Python_SetConstant(d, "CapFloor_Floor",SWIG_From_int(static_cast< int >(CapFloor::Floor)));
  SWIG_Python_SetConstant(d, "CapFloor_Collar",SWIG_From_int(static_cast< int >(CapFloor::Collar)));
  SWIG_Python_SetConstant(d, "Futures_IMM",SWIG_From_int(static_cast< int >(Futures::IMM)));
  SWIG_Python_SetConstant(d, "Futures_ASX",SWIG_From_int(static_cast< int >(Futures::ASX)));
  SWIG_Python_SetConstant(d, "OvernightIndexFuture_Averaging",SWIG_From_int(static_cast< int >(OvernightIndexFuture::Averaging)));
  SWIG_Python_SetConstant(d, "OvernightIndexFuture_Compounding",SWIG_From_int(static_cast< int >(OvernightIndexFuture::Compounding)));
  SWIG_Python_SetConstant(d, "Pillar_MaturityDate",SWIG_From_int(static_cast< int >(Pillar::MaturityDate)));
  SWIG_Python_SetConstant(d, "Pillar_LastRelevantDate",SWIG_From_int(static_cast< int >(Pillar::LastRelevantDate)));
  SWIG_Python_SetConstant(d, "Pillar_CustomDate",SWIG_From_int(static_cast< int >(Pillar::CustomDate)));
  SWIG_Python_SetConstant(d, "Protection_Buyer",SWIG_From_int(static_cast< int >(Protection::Buyer)));
  SWIG_Python_SetConstant(d, "Protection_Seller",SWIG_From_int(static_cast< int >(Protection::Seller)));
  SWIG_Python_SetConstant(d, "CreditDefaultSwap_Midpoint",SWIG_From_int(static_cast< int >(CreditDefaultSwap::Midpoint)));
  SWIG_Python_SetConstant(d, "CreditDefaultSwap_ISDA",SWIG_From_int(static_cast< int >(CreditDefaultSwap::ISDA)));
  SWIG_Python_SetConstant(d, "IsdaCdsEngine_NoFix",SWIG_From_int(static_cast< int >(IsdaCdsEngine::None)));
  SWIG_Python_SetConstant(d, "IsdaCdsEngine_Taylor",SWIG_From_int(static_cast< int >(IsdaCdsEngine::Taylor)));
  SWIG_Python_SetConstant(d, "IsdaCdsEngine_HalfDayBias",SWIG_From_int(static_cast< int >(IsdaCdsEngine::HalfDayBias)));
  SWIG_Python_SetConstant(d, "IsdaCdsEngine_NoBias",SWIG_From_int(static_cast< int >(IsdaCdsEngine::NoBias)));
  SWIG_Python_SetConstant(d, "IsdaCdsEngine_Flat",SWIG_From_int(static_cast< int >(IsdaCdsEngine::Flat)));
  SWIG_Python_SetConstant(d, "IsdaCdsEngine_Piecewise",SWIG_From_int(static_cast< int >(IsdaCdsEngine::Piecewise)));
  SWIG_Python_SetConstant(d, "Money_NoConversion",SWIG_From_int(static_cast< int >(Money::NoConversion)));
  SWIG_Python_SetConstant(d, "Money_BaseCurrencyConversion",SWIG_From_int(static_cast< int >(Money::BaseCurrencyConversion)));
  SWIG_Python_SetConstant(d, "Money_AutomatedConversion",SWIG_From_int(static_cast< int >(Money::AutomatedConversion)));
  SWIG_Python_SetConstant(d, "ExchangeRate_Direct",SWIG_From_int(static_cast< int >(ExchangeRate::Direct)));
  SWIG_Python_SetConstant(d, "ExchangeRate_Derived",SWIG_From_int(static_cast< int >(ExchangeRate::Derived)));
  SWIG_Python_SetConstant(d, "FdmBoundaryCondition_NoSide",SWIG_From_int(static_cast< int >(FdmBoundaryCondition::None)));
  SWIG_Python_SetConstant(d, "FdmBoundaryCondition_Upper",SWIG_From_int(static_cast< int >(FdmBoundaryCondition::Upper)));
  SWIG_Python_SetConstant(d, "FdmBoundaryCondition_Lower",SWIG_From_int(static_cast< int >(FdmBoundaryCondition::Lower)));
  SWIG_Python_SetConstant(d, "FdmSquareRootFwdOp_Plain",SWIG_From_int(static_cast< int >(FdmSquareRootFwdOp::Plain)));
  SWIG_Python_SetConstant(d, "FdmSquareRootFwdOp_Power",SWIG_From_int(static_cast< int >(FdmSquareRootFwdOp::Power)));
  SWIG_Python_SetConstant(d, "FdmSquareRootFwdOp_Log",SWIG_From_int(static_cast< int >(FdmSquareRootFwdOp::Log)));
  SWIG_Python_SetConstant(d, "ImplicitEulerScheme_BiCGstab",SWIG_From_int(static_cast< int >(ImplicitEulerScheme::BiCGstab)));
  SWIG_Python_SetConstant(d, "ImplicitEulerScheme_GMRES",SWIG_From_int(static_cast< int >(ImplicitEulerScheme::GMRES)));
  SWIG_Python_SetConstant(d, "Position_Long",SWIG_From_int(static_cast< int >(Position::Long)));
  SWIG_Python_SetConstant(d, "Position_Short",SWIG_From_int(static_cast< int >(Position::Short)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_AdjustNone",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::AdjustNone)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_AdjustDigitals",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::AdjustDigitals)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_AdjustYts",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::AdjustYts)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_ExtrapolatePayoffFlat",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::ExtrapolatePayoffFlat)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_NoPayoffExtrapolation",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::NoPayoffExtrapolation)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_KahaleSmile",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::KahaleSmile)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_SmileExponentialExtrapolation",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::SmileExponentialExtrapolation)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_KahaleInterpolation",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::KahaleInterpolation)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_SmileDeleteArbitragePoints",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::SmileDeleteArbitragePoints)));
  SWIG_Python_SetConstant(d, "MarkovFunctionalSettings_SabrSmile",SWIG_From_int(static_cast< int >(MarkovFunctional::ModelSettings::SabrSmile)));
  SWIG_Python_SetConstant(d, "Gaussian1dSwaptionEngine_NoProb",SWIG_From_int(static_cast< int >(Gaussian1dSwaptionEngine::None)));
  SWIG_Python_SetConstant(d, "Gaussian1dSwaptionEngine_Naive",SWIG_From_int(static_cast< int >(Gaussian1dSwaptionEngine::Naive)));
  SWIG_Python_SetConstant(d, "Gaussian1dSwaptionEngine_Digital",SWIG_From_int(static_cast< int >(Gaussian1dSwaptionEngine::Digital)));
  SWIG_Python_SetConstant(d, "Gaussian1dNonstandardSwaptionEngine_NoProb",SWIG_From_int(static_cast< int >(Gaussian1dNonstandardSwaptionEngine::None)));
  SWIG_Python_SetConstant(d, "Gaussian1dNonstandardSwaptionEngine_Naive",SWIG_From_int(static_cast< int >(Gaussian1dNonstandardSwaptionEngine::Naive)));
  SWIG_Python_SetConstant(d, "Gaussian1dNonstandardSwaptionEngine_Digital",SWIG_From_int(static_cast< int >(Gaussian1dNonstandardSwaptionEngine::Digital)));
  SWIG_Python_SetConstant(d, "Gaussian1dFloatFloatSwaptionEngine_NoProb",SWIG_From_int(static_cast< int >(Gaussian1dFloatFloatSwaptionEngine::None)));
  SWIG_Python_SetConstant(d, "Gaussian1dFloatFloatSwaptionEngine_Naive",SWIG_From_int(static_cast< int >(Gaussian1dFloatFloatSwaptionEngine::Naive)));
  SWIG_Python_SetConstant(d, "Gaussian1dFloatFloatSwaptionEngine_Digital",SWIG_From_int(static_cast< int >(Gaussian1dFloatFloatSwaptionEngine::Digital)));
  SWIG_Python_SetConstant(d, "SobolRsg_Unit",SWIG_From_int(static_cast< int >(SobolRsg::Unit)));
  SWIG_Python_SetConstant(d, "SobolRsg_Jaeckel",SWIG_From_int(static_cast< int >(SobolRsg::Jaeckel)));
  SWIG_Python_SetConstant(d, "SobolRsg_SobolLevitan",SWIG_From_int(static_cast< int >(SobolRsg::SobolLevitan)));
  SWIG_Python_SetConstant(d, "SobolRsg_SobolLevitanLemieux",SWIG_From_int(static_cast< int >(SobolRsg::SobolLevitanLemieux)));
  SWIG_Python_SetConstant(d, "SobolRsg_JoeKuoD5",SWIG_From_int(static_cast< int >(SobolRsg::JoeKuoD5)));
  SWIG_Python_SetConstant(d, "SobolRsg_JoeKuoD6",SWIG_From_int(static_cast< int >(SobolRsg::JoeKuoD6)));
  SWIG_Python_SetConstant(d, "SobolRsg_JoeKuoD7",SWIG_From_int(static_cast< int >(SobolRsg::JoeKuoD7)));
  SWIG_Python_SetConstant(d, "SobolRsg_Kuo",SWIG_From_int(static_cast< int >(SobolRsg::Kuo)));
  SWIG_Python_SetConstant(d, "SobolRsg_Kuo2",SWIG_From_int(static_cast< int >(SobolRsg::Kuo2)));
  SWIG_Python_SetConstant(d, "SobolRsg_Kuo3",SWIG_From_int(static_cast< int >(SobolRsg::Kuo3)));
  SWIG_Python_SetConstant(d, "DefaultBoundaryCondition_NoSide",SWIG_From_int(static_cast< int >(DefaultBoundaryCondition::None)));
  SWIG_Python_SetConstant(d, "DefaultBoundaryCondition_Upper",SWIG_From_int(static_cast< int >(DefaultBoundaryCondition::Upper)));
  SWIG_Python_SetConstant(d, "DefaultBoundaryCondition_Lower",SWIG_From_int(static_cast< int >(DefaultBoundaryCondition::Lower)));
  SWIG_Python_SetConstant(d, "SobolBrownianGenerator_Factors",SWIG_From_int(static_cast< int >(SobolBrownianGenerator::Factors)));
  SWIG_Python_SetConstant(d, "SobolBrownianGenerator_Steps",SWIG_From_int(static_cast< int >(SobolBrownianGenerator::Steps)));
  SWIG_Python_SetConstant(d, "SobolBrownianGenerator_Diagonal",SWIG_From_int(static_cast< int >(SobolBrownianGenerator::Diagonal)));
  SWIG_Python_SetConstant(d, "FdmHestonGreensFct_ZeroCorrelation",SWIG_From_int(static_cast< int >(FdmHestonGreensFct::ZeroCorrelation)));
  SWIG_Python_SetConstant(d, "FdmHestonGreensFct_Gaussian",SWIG_From_int(static_cast< int >(FdmHestonGreensFct::Gaussian)));
  SWIG_Python_SetConstant(d, "FdmHestonGreensFct_SemiAnalytical",SWIG_From_int(static_cast< int >(FdmHestonGreensFct::SemiAnalytical)));
  SWIG_Python_SetConstant(d, "Settlement_Physical",SWIG_From_int(static_cast< int >(Settlement::Physical)));
  SWIG_Python_SetConstant(d, "Settlement_Cash",SWIG_From_int(static_cast< int >(Settlement::Cash)));
  SWIG_Python_SetConstant(d, "Settlement_PhysicalOTC",SWIG_From_int(static_cast< int >(Settlement::PhysicalOTC)));
  SWIG_Python_SetConstant(d, "Settlement_PhysicalCleared",SWIG_From_int(static_cast< int >(Settlement::PhysicalCleared)));
  SWIG_Python_SetConstant(d, "Settlement_CollateralizedCashPrice",SWIG_From_int(static_cast< int >(Settlement::CollateralizedCashPrice)));
  SWIG_Python_SetConstant(d, "Settlement_ParYieldCurve",SWIG_From_int(static_cast< int >(Settlement::ParYieldCurve)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

