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

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_QuantLib', [dirname(__file__)])
        except ImportError:
            import _QuantLib
            return _QuantLib
        if fp is not None:
            try:
                _mod = imp.load_module('_QuantLib', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _QuantLib = swig_import_helper()
    del swig_import_helper
else:
    import _QuantLib
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class SwigPyIterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _QuantLib.SwigPyIterator_value(self)
    def incr(self, n = 1): return _QuantLib.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _QuantLib.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _QuantLib.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _QuantLib.SwigPyIterator_equal(self, *args)
    def copy(self): return _QuantLib.SwigPyIterator_copy(self)
    def next(self): return _QuantLib.SwigPyIterator_next(self)
    def __next__(self): return _QuantLib.SwigPyIterator___next__(self)
    def previous(self): return _QuantLib.SwigPyIterator_previous(self)
    def advance(self, *args): return _QuantLib.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _QuantLib.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _QuantLib.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _QuantLib.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _QuantLib.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _QuantLib.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _QuantLib.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _QuantLib.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
cvar = _QuantLib.cvar
__hexversion__ = cvar.__hexversion__
__version__ = cvar.__version__

Sunday = _QuantLib.Sunday
Monday = _QuantLib.Monday
Tuesday = _QuantLib.Tuesday
Wednesday = _QuantLib.Wednesday
Thursday = _QuantLib.Thursday
Friday = _QuantLib.Friday
Saturday = _QuantLib.Saturday
January = _QuantLib.January
February = _QuantLib.February
March = _QuantLib.March
April = _QuantLib.April
May = _QuantLib.May
June = _QuantLib.June
July = _QuantLib.July
August = _QuantLib.August
September = _QuantLib.September
October = _QuantLib.October
November = _QuantLib.November
December = _QuantLib.December
Days = _QuantLib.Days
Weeks = _QuantLib.Weeks
Months = _QuantLib.Months
Years = _QuantLib.Years
NoFrequency = _QuantLib.NoFrequency
Once = _QuantLib.Once
Annual = _QuantLib.Annual
Semiannual = _QuantLib.Semiannual
EveryFourthMonth = _QuantLib.EveryFourthMonth
Quarterly = _QuantLib.Quarterly
Bimonthly = _QuantLib.Bimonthly
Monthly = _QuantLib.Monthly
EveryFourthWeek = _QuantLib.EveryFourthWeek
Biweekly = _QuantLib.Biweekly
Weekly = _QuantLib.Weekly
Daily = _QuantLib.Daily
OtherFrequency = _QuantLib.OtherFrequency
class Period(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def length(self): return _QuantLib.Period_length(self)
    def units(self): return _QuantLib.Period_units(self)
    def frequency(self): return _QuantLib.Period_frequency(self)
    def __init__(self, *args): 
        this = _QuantLib.new_Period(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _QuantLib.Period___str__(self)
    def __repr__(self): return _QuantLib.Period___repr__(self)
    def __neg__(self): return _QuantLib.Period___neg__(self)
    def __mul__(self, *args): return _QuantLib.Period___mul__(self, *args)
    def __rmul__(self, *args): return _QuantLib.Period___rmul__(self, *args)
    def __cmp__(self, *args): return _QuantLib.Period___cmp__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Period
    __del__ = lambda self : None;
Period_swigregister = _QuantLib.Period_swigregister
Period_swigregister(Period)

class PeriodVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.PeriodVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.PeriodVector___nonzero__(self)
    def __bool__(self): return _QuantLib.PeriodVector___bool__(self)
    def __len__(self): return _QuantLib.PeriodVector___len__(self)
    def pop(self): return _QuantLib.PeriodVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.PeriodVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.PeriodVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.PeriodVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.PeriodVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.PeriodVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.PeriodVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.PeriodVector_append(self, *args)
    def empty(self): return _QuantLib.PeriodVector_empty(self)
    def size(self): return _QuantLib.PeriodVector_size(self)
    def clear(self): return _QuantLib.PeriodVector_clear(self)
    def swap(self, *args): return _QuantLib.PeriodVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.PeriodVector_get_allocator(self)
    def begin(self): return _QuantLib.PeriodVector_begin(self)
    def end(self): return _QuantLib.PeriodVector_end(self)
    def rbegin(self): return _QuantLib.PeriodVector_rbegin(self)
    def rend(self): return _QuantLib.PeriodVector_rend(self)
    def pop_back(self): return _QuantLib.PeriodVector_pop_back(self)
    def erase(self, *args): return _QuantLib.PeriodVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_PeriodVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.PeriodVector_push_back(self, *args)
    def front(self): return _QuantLib.PeriodVector_front(self)
    def back(self): return _QuantLib.PeriodVector_back(self)
    def assign(self, *args): return _QuantLib.PeriodVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.PeriodVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.PeriodVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.PeriodVector_reserve(self, *args)
    def capacity(self): return _QuantLib.PeriodVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_PeriodVector
    __del__ = lambda self : None;
PeriodVector_swigregister = _QuantLib.PeriodVector_swigregister
PeriodVector_swigregister(PeriodVector)

class Date(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def weekday(self): return _QuantLib.Date_weekday(self)
    def dayOfMonth(self): return _QuantLib.Date_dayOfMonth(self)
    def dayOfYear(self): return _QuantLib.Date_dayOfYear(self)
    def month(self): return _QuantLib.Date_month(self)
    def year(self): return _QuantLib.Date_year(self)
    def serialNumber(self): return _QuantLib.Date_serialNumber(self)
    isLeap = staticmethod(_QuantLib.Date_isLeap)
    minDate = staticmethod(_QuantLib.Date_minDate)
    maxDate = staticmethod(_QuantLib.Date_maxDate)
    todaysDate = staticmethod(_QuantLib.Date_todaysDate)
    endOfMonth = staticmethod(_QuantLib.Date_endOfMonth)
    isEndOfMonth = staticmethod(_QuantLib.Date_isEndOfMonth)
    nextWeekday = staticmethod(_QuantLib.Date_nextWeekday)
    nthWeekday = staticmethod(_QuantLib.Date_nthWeekday)
    def __add__(self, *args): return _QuantLib.Date___add__(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_Date(*args)
        try: self.this.append(this)
        except: self.this = this
    def weekdayNumber(self): return _QuantLib.Date_weekdayNumber(self)
    def __str__(self): return _QuantLib.Date___str__(self)
    def __repr__(self): return _QuantLib.Date___repr__(self)
    def ISO(self): return _QuantLib.Date_ISO(self)
    def __sub__(self, *args): return _QuantLib.Date___sub__(self, *args)
    def __cmp__(self, *args): return _QuantLib.Date___cmp__(self, *args)
    def __nonzero__(self): return _QuantLib.Date___nonzero__(self)
    def __hash__(self): return _QuantLib.Date___hash__(self)
    __swig_destroy__ = _QuantLib.delete_Date
    __del__ = lambda self : None;
Date_swigregister = _QuantLib.Date_swigregister
Date_swigregister(Date)

def Date_isLeap(*args):
  return _QuantLib.Date_isLeap(*args)
Date_isLeap = _QuantLib.Date_isLeap

def Date_minDate():
  return _QuantLib.Date_minDate()
Date_minDate = _QuantLib.Date_minDate

def Date_maxDate():
  return _QuantLib.Date_maxDate()
Date_maxDate = _QuantLib.Date_maxDate

def Date_todaysDate():
  return _QuantLib.Date_todaysDate()
Date_todaysDate = _QuantLib.Date_todaysDate

def Date_endOfMonth(*args):
  return _QuantLib.Date_endOfMonth(*args)
Date_endOfMonth = _QuantLib.Date_endOfMonth

def Date_isEndOfMonth(*args):
  return _QuantLib.Date_isEndOfMonth(*args)
Date_isEndOfMonth = _QuantLib.Date_isEndOfMonth

def Date_nextWeekday(*args):
  return _QuantLib.Date_nextWeekday(*args)
Date_nextWeekday = _QuantLib.Date_nextWeekday

def Date_nthWeekday(*args):
  return _QuantLib.Date_nthWeekday(*args)
Date_nthWeekday = _QuantLib.Date_nthWeekday

class DateParser(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    parse = staticmethod(_QuantLib.DateParser_parse)
    parseISO = staticmethod(_QuantLib.DateParser_parseISO)
    def __init__(self): 
        this = _QuantLib.new_DateParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DateParser
    __del__ = lambda self : None;
DateParser_swigregister = _QuantLib.DateParser_swigregister
DateParser_swigregister(DateParser)

def DateParser_parse(*args):
  return _QuantLib.DateParser_parse(*args)
DateParser_parse = _QuantLib.DateParser_parse

def DateParser_parseISO(*args):
  return _QuantLib.DateParser_parseISO(*args)
DateParser_parseISO = _QuantLib.DateParser_parseISO

class PeriodParser(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    parse = staticmethod(_QuantLib.PeriodParser_parse)
    def __init__(self): 
        this = _QuantLib.new_PeriodParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PeriodParser
    __del__ = lambda self : None;
PeriodParser_swigregister = _QuantLib.PeriodParser_swigregister
PeriodParser_swigregister(PeriodParser)

def PeriodParser_parse(*args):
  return _QuantLib.PeriodParser_parse(*args)
PeriodParser_parse = _QuantLib.PeriodParser_parse

Date._old___add__ = Date.__add__
Date._old___sub__ = Date.__sub__
def Date_new___add__(self,x):
    if type(x) is tuple and len(x) == 2:
        return self._old___add__(Period(x[0],x[1]))
    else:
        return self._old___add__(x)
def Date_new___sub__(self,x):
    if type(x) is tuple and len(x) == 2:
        return self._old___sub__(Period(x[0],x[1]))
    else:
        return self._old___sub__(x)
Date.__add__ = Date_new___add__
Date.__sub__ = Date_new___sub__

class DateVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.DateVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.DateVector___nonzero__(self)
    def __bool__(self): return _QuantLib.DateVector___bool__(self)
    def __len__(self): return _QuantLib.DateVector___len__(self)
    def pop(self): return _QuantLib.DateVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.DateVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.DateVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.DateVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.DateVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.DateVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.DateVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.DateVector_append(self, *args)
    def empty(self): return _QuantLib.DateVector_empty(self)
    def size(self): return _QuantLib.DateVector_size(self)
    def clear(self): return _QuantLib.DateVector_clear(self)
    def swap(self, *args): return _QuantLib.DateVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.DateVector_get_allocator(self)
    def begin(self): return _QuantLib.DateVector_begin(self)
    def end(self): return _QuantLib.DateVector_end(self)
    def rbegin(self): return _QuantLib.DateVector_rbegin(self)
    def rend(self): return _QuantLib.DateVector_rend(self)
    def pop_back(self): return _QuantLib.DateVector_pop_back(self)
    def erase(self, *args): return _QuantLib.DateVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_DateVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.DateVector_push_back(self, *args)
    def front(self): return _QuantLib.DateVector_front(self)
    def back(self): return _QuantLib.DateVector_back(self)
    def assign(self, *args): return _QuantLib.DateVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.DateVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.DateVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.DateVector_reserve(self, *args)
    def capacity(self): return _QuantLib.DateVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DateVector
    __del__ = lambda self : None;
DateVector_swigregister = _QuantLib.DateVector_swigregister
DateVector_swigregister(DateVector)

class IMM(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    F = _QuantLib.IMM_F
    G = _QuantLib.IMM_G
    H = _QuantLib.IMM_H
    J = _QuantLib.IMM_J
    K = _QuantLib.IMM_K
    M = _QuantLib.IMM_M
    N = _QuantLib.IMM_N
    Q = _QuantLib.IMM_Q
    U = _QuantLib.IMM_U
    V = _QuantLib.IMM_V
    X = _QuantLib.IMM_X
    Z = _QuantLib.IMM_Z
    isIMMdate = staticmethod(_QuantLib.IMM_isIMMdate)
    isIMMcode = staticmethod(_QuantLib.IMM_isIMMcode)
    code = staticmethod(_QuantLib.IMM_code)
    date = staticmethod(_QuantLib.IMM_date)
    nextDate = staticmethod(_QuantLib.IMM_nextDate)
    nextCode = staticmethod(_QuantLib.IMM_nextCode)
    def __init__(self): 
        this = _QuantLib.new_IMM()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_IMM
    __del__ = lambda self : None;
IMM_swigregister = _QuantLib.IMM_swigregister
IMM_swigregister(IMM)

def IMM_isIMMdate(*args):
  return _QuantLib.IMM_isIMMdate(*args)
IMM_isIMMdate = _QuantLib.IMM_isIMMdate

def IMM_isIMMcode(*args):
  return _QuantLib.IMM_isIMMcode(*args)
IMM_isIMMcode = _QuantLib.IMM_isIMMcode

def IMM_code(*args):
  return _QuantLib.IMM_code(*args)
IMM_code = _QuantLib.IMM_code

def IMM_date(*args):
  return _QuantLib.IMM_date(*args)
IMM_date = _QuantLib.IMM_date

def IMM_nextDate(*args):
  return _QuantLib.IMM_nextDate(*args)
IMM_nextDate = _QuantLib.IMM_nextDate

def IMM_nextCode(*args):
  return _QuantLib.IMM_nextCode(*args)
IMM_nextCode = _QuantLib.IMM_nextCode

class IntVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.IntVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.IntVector___nonzero__(self)
    def __bool__(self): return _QuantLib.IntVector___bool__(self)
    def __len__(self): return _QuantLib.IntVector___len__(self)
    def pop(self): return _QuantLib.IntVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.IntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.IntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.IntVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.IntVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.IntVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.IntVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.IntVector_append(self, *args)
    def empty(self): return _QuantLib.IntVector_empty(self)
    def size(self): return _QuantLib.IntVector_size(self)
    def clear(self): return _QuantLib.IntVector_clear(self)
    def swap(self, *args): return _QuantLib.IntVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.IntVector_get_allocator(self)
    def begin(self): return _QuantLib.IntVector_begin(self)
    def end(self): return _QuantLib.IntVector_end(self)
    def rbegin(self): return _QuantLib.IntVector_rbegin(self)
    def rend(self): return _QuantLib.IntVector_rend(self)
    def pop_back(self): return _QuantLib.IntVector_pop_back(self)
    def erase(self, *args): return _QuantLib.IntVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_IntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.IntVector_push_back(self, *args)
    def front(self): return _QuantLib.IntVector_front(self)
    def back(self): return _QuantLib.IntVector_back(self)
    def assign(self, *args): return _QuantLib.IntVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.IntVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.IntVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.IntVector_reserve(self, *args)
    def capacity(self): return _QuantLib.IntVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_IntVector
    __del__ = lambda self : None;
IntVector_swigregister = _QuantLib.IntVector_swigregister
IntVector_swigregister(IntVector)

class UnsignedIntVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.UnsignedIntVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.UnsignedIntVector___nonzero__(self)
    def __bool__(self): return _QuantLib.UnsignedIntVector___bool__(self)
    def __len__(self): return _QuantLib.UnsignedIntVector___len__(self)
    def pop(self): return _QuantLib.UnsignedIntVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.UnsignedIntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.UnsignedIntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.UnsignedIntVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.UnsignedIntVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.UnsignedIntVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.UnsignedIntVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.UnsignedIntVector_append(self, *args)
    def empty(self): return _QuantLib.UnsignedIntVector_empty(self)
    def size(self): return _QuantLib.UnsignedIntVector_size(self)
    def clear(self): return _QuantLib.UnsignedIntVector_clear(self)
    def swap(self, *args): return _QuantLib.UnsignedIntVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.UnsignedIntVector_get_allocator(self)
    def begin(self): return _QuantLib.UnsignedIntVector_begin(self)
    def end(self): return _QuantLib.UnsignedIntVector_end(self)
    def rbegin(self): return _QuantLib.UnsignedIntVector_rbegin(self)
    def rend(self): return _QuantLib.UnsignedIntVector_rend(self)
    def pop_back(self): return _QuantLib.UnsignedIntVector_pop_back(self)
    def erase(self, *args): return _QuantLib.UnsignedIntVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_UnsignedIntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.UnsignedIntVector_push_back(self, *args)
    def front(self): return _QuantLib.UnsignedIntVector_front(self)
    def back(self): return _QuantLib.UnsignedIntVector_back(self)
    def assign(self, *args): return _QuantLib.UnsignedIntVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.UnsignedIntVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.UnsignedIntVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.UnsignedIntVector_reserve(self, *args)
    def capacity(self): return _QuantLib.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_UnsignedIntVector
    __del__ = lambda self : None;
UnsignedIntVector_swigregister = _QuantLib.UnsignedIntVector_swigregister
UnsignedIntVector_swigregister(UnsignedIntVector)

class DoubleVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.DoubleVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.DoubleVector___nonzero__(self)
    def __bool__(self): return _QuantLib.DoubleVector___bool__(self)
    def __len__(self): return _QuantLib.DoubleVector___len__(self)
    def pop(self): return _QuantLib.DoubleVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.DoubleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.DoubleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.DoubleVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.DoubleVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.DoubleVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.DoubleVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.DoubleVector_append(self, *args)
    def empty(self): return _QuantLib.DoubleVector_empty(self)
    def size(self): return _QuantLib.DoubleVector_size(self)
    def clear(self): return _QuantLib.DoubleVector_clear(self)
    def swap(self, *args): return _QuantLib.DoubleVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.DoubleVector_get_allocator(self)
    def begin(self): return _QuantLib.DoubleVector_begin(self)
    def end(self): return _QuantLib.DoubleVector_end(self)
    def rbegin(self): return _QuantLib.DoubleVector_rbegin(self)
    def rend(self): return _QuantLib.DoubleVector_rend(self)
    def pop_back(self): return _QuantLib.DoubleVector_pop_back(self)
    def erase(self, *args): return _QuantLib.DoubleVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_DoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.DoubleVector_push_back(self, *args)
    def front(self): return _QuantLib.DoubleVector_front(self)
    def back(self): return _QuantLib.DoubleVector_back(self)
    def assign(self, *args): return _QuantLib.DoubleVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.DoubleVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.DoubleVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.DoubleVector_reserve(self, *args)
    def capacity(self): return _QuantLib.DoubleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DoubleVector
    __del__ = lambda self : None;
DoubleVector_swigregister = _QuantLib.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class StrVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.StrVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.StrVector___nonzero__(self)
    def __bool__(self): return _QuantLib.StrVector___bool__(self)
    def __len__(self): return _QuantLib.StrVector___len__(self)
    def pop(self): return _QuantLib.StrVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.StrVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.StrVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.StrVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.StrVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.StrVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.StrVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.StrVector_append(self, *args)
    def empty(self): return _QuantLib.StrVector_empty(self)
    def size(self): return _QuantLib.StrVector_size(self)
    def clear(self): return _QuantLib.StrVector_clear(self)
    def swap(self, *args): return _QuantLib.StrVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.StrVector_get_allocator(self)
    def begin(self): return _QuantLib.StrVector_begin(self)
    def end(self): return _QuantLib.StrVector_end(self)
    def rbegin(self): return _QuantLib.StrVector_rbegin(self)
    def rend(self): return _QuantLib.StrVector_rend(self)
    def pop_back(self): return _QuantLib.StrVector_pop_back(self)
    def erase(self, *args): return _QuantLib.StrVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_StrVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.StrVector_push_back(self, *args)
    def front(self): return _QuantLib.StrVector_front(self)
    def back(self): return _QuantLib.StrVector_back(self)
    def assign(self, *args): return _QuantLib.StrVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.StrVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.StrVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.StrVector_reserve(self, *args)
    def capacity(self): return _QuantLib.StrVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StrVector
    __del__ = lambda self : None;
StrVector_swigregister = _QuantLib.StrVector_swigregister
StrVector_swigregister(StrVector)

class NodePair(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_NodePair(*args)
        try: self.this.append(this)
        except: self.this = this
    first = _swig_property(_QuantLib.NodePair_first_get, _QuantLib.NodePair_first_set)
    second = _swig_property(_QuantLib.NodePair_second_get, _QuantLib.NodePair_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _QuantLib.delete_NodePair
    __del__ = lambda self : None;
NodePair_swigregister = _QuantLib.NodePair_swigregister
NodePair_swigregister(NodePair)

class NodeVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.NodeVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.NodeVector___nonzero__(self)
    def __bool__(self): return _QuantLib.NodeVector___bool__(self)
    def __len__(self): return _QuantLib.NodeVector___len__(self)
    def pop(self): return _QuantLib.NodeVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.NodeVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.NodeVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.NodeVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.NodeVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.NodeVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.NodeVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.NodeVector_append(self, *args)
    def empty(self): return _QuantLib.NodeVector_empty(self)
    def size(self): return _QuantLib.NodeVector_size(self)
    def clear(self): return _QuantLib.NodeVector_clear(self)
    def swap(self, *args): return _QuantLib.NodeVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.NodeVector_get_allocator(self)
    def begin(self): return _QuantLib.NodeVector_begin(self)
    def end(self): return _QuantLib.NodeVector_end(self)
    def rbegin(self): return _QuantLib.NodeVector_rbegin(self)
    def rend(self): return _QuantLib.NodeVector_rend(self)
    def pop_back(self): return _QuantLib.NodeVector_pop_back(self)
    def erase(self, *args): return _QuantLib.NodeVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_NodeVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.NodeVector_push_back(self, *args)
    def front(self): return _QuantLib.NodeVector_front(self)
    def back(self): return _QuantLib.NodeVector_back(self)
    def assign(self, *args): return _QuantLib.NodeVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.NodeVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.NodeVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.NodeVector_reserve(self, *args)
    def capacity(self): return _QuantLib.NodeVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_NodeVector
    __del__ = lambda self : None;
NodeVector_swigregister = _QuantLib.NodeVector_swigregister
NodeVector_swigregister(NodeVector)

class Exercise(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Exercise___deref__(self)
    def __nonzero__(self): return _QuantLib.Exercise___nonzero__(self)
    American = _QuantLib.Exercise_American
    Bermudan = _QuantLib.Exercise_Bermudan
    European = _QuantLib.Exercise_European
    def __init__(self): 
        this = _QuantLib.new_Exercise()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Exercise
    __del__ = lambda self : None;
    def type(self): return _QuantLib.Exercise_type(self)
    def dates(self): return _QuantLib.Exercise_dates(self)
Exercise_swigregister = _QuantLib.Exercise_swigregister
Exercise_swigregister(Exercise)

class EuropeanExercise(Exercise):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EuropeanExercise(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EuropeanExercise
    __del__ = lambda self : None;
EuropeanExercise_swigregister = _QuantLib.EuropeanExercise_swigregister
EuropeanExercise_swigregister(EuropeanExercise)

class AmericanExercise(Exercise):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AmericanExercise(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AmericanExercise
    __del__ = lambda self : None;
AmericanExercise_swigregister = _QuantLib.AmericanExercise_swigregister
AmericanExercise_swigregister(AmericanExercise)

class BermudanExercise(Exercise):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BermudanExercise(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BermudanExercise
    __del__ = lambda self : None;
BermudanExercise_swigregister = _QuantLib.BermudanExercise_swigregister
BermudanExercise_swigregister(BermudanExercise)

class Observable(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Observable___deref__(self)
    def __nonzero__(self): return _QuantLib.Observable___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_Observable()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Observable
    __del__ = lambda self : None;
Observable_swigregister = _QuantLib.Observable_swigregister
Observable_swigregister(Observable)

class Observer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Observer(*args)
        try: self.this.append(this)
        except: self.this = this
    def _registerWith(self, *args): return _QuantLib.Observer__registerWith(self, *args)
    def _unregisterWith(self, *args): return _QuantLib.Observer__unregisterWith(self, *args)
    def registerWith(self,x):
        self._registerWith(x.asObservable())
    def unregisterWith(self,x):
        self._unregisterWith(x.asObservable())

    __swig_destroy__ = _QuantLib.delete_Observer
    __del__ = lambda self : None;
Observer_swigregister = _QuantLib.Observer_swigregister
Observer_swigregister(Observer)

class Array(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Array(*args)
        try: self.this.append(this)
        except: self.this = this
    def __len__(self): return _QuantLib.Array___len__(self)
    def __str__(self): return _QuantLib.Array___str__(self)
    def __add__(self, *args): return _QuantLib.Array___add__(self, *args)
    def __sub__(self, *args): return _QuantLib.Array___sub__(self, *args)
    def __mul__(self, *args): return _QuantLib.Array___mul__(self, *args)
    def __div__(self, *args): return _QuantLib.Array___div__(self, *args)
    def __rmul__(self, *args): return _QuantLib.Array___rmul__(self, *args)
    def __getslice__(self, *args): return _QuantLib.Array___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.Array___setslice__(self, *args)
    def __nonzero__(self): return _QuantLib.Array___nonzero__(self)
    def __getitem__(self, *args): return _QuantLib.Array___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.Array___setitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Array
    __del__ = lambda self : None;
Array_swigregister = _QuantLib.Array_swigregister
Array_swigregister(Array)

class DefaultLexicographicalViewColumn(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __getitem__(self, *args): return _QuantLib.DefaultLexicographicalViewColumn___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.DefaultLexicographicalViewColumn___setitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_DefaultLexicographicalViewColumn
    __del__ = lambda self : None;
DefaultLexicographicalViewColumn_swigregister = _QuantLib.DefaultLexicographicalViewColumn_swigregister
DefaultLexicographicalViewColumn_swigregister(DefaultLexicographicalViewColumn)

class LexicographicalView(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def xSize(self): return _QuantLib.LexicographicalView_xSize(self)
    def ySize(self): return _QuantLib.LexicographicalView_ySize(self)
    def __init__(self, *args): 
        this = _QuantLib.new_LexicographicalView(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _QuantLib.LexicographicalView___str__(self)
    def __getitem__(self, *args): return _QuantLib.LexicographicalView___getitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_LexicographicalView
    __del__ = lambda self : None;
LexicographicalView_swigregister = _QuantLib.LexicographicalView_swigregister
LexicographicalView_swigregister(LexicographicalView)

class MatrixRow(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __getitem__(self, *args): return _QuantLib.MatrixRow___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.MatrixRow___setitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_MatrixRow
    __del__ = lambda self : None;
MatrixRow_swigregister = _QuantLib.MatrixRow_swigregister
MatrixRow_swigregister(MatrixRow)

class Matrix(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Matrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def rows(self): return _QuantLib.Matrix_rows(self)
    def columns(self): return _QuantLib.Matrix_columns(self)
    def __str__(self): return _QuantLib.Matrix___str__(self)
    def __add__(self, *args): return _QuantLib.Matrix___add__(self, *args)
    def __sub__(self, *args): return _QuantLib.Matrix___sub__(self, *args)
    def __mul__(self, *args): return _QuantLib.Matrix___mul__(self, *args)
    def __div__(self, *args): return _QuantLib.Matrix___div__(self, *args)
    def __getitem__(self, *args): return _QuantLib.Matrix___getitem__(self, *args)
    def __rmul__(self, *args): return _QuantLib.Matrix___rmul__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Matrix
    __del__ = lambda self : None;
Matrix_swigregister = _QuantLib.Matrix_swigregister
Matrix_swigregister(Matrix)

class SalvagingAlgorithm(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NoAlgorithm = _QuantLib.SalvagingAlgorithm_NoAlgorithm
    Spectral = _QuantLib.SalvagingAlgorithm_Spectral
    def __init__(self): 
        this = _QuantLib.new_SalvagingAlgorithm()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SalvagingAlgorithm
    __del__ = lambda self : None;
SalvagingAlgorithm_swigregister = _QuantLib.SalvagingAlgorithm_swigregister
SalvagingAlgorithm_swigregister(SalvagingAlgorithm)


def transpose(*args):
  return _QuantLib.transpose(*args)
transpose = _QuantLib.transpose

def outerProduct(*args):
  return _QuantLib.outerProduct(*args)
outerProduct = _QuantLib.outerProduct

def pseudoSqrt(*args):
  return _QuantLib.pseudoSqrt(*args)
pseudoSqrt = _QuantLib.pseudoSqrt
class SVD(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SVD(*args)
        try: self.this.append(this)
        except: self.this = this
    def U(self): return _QuantLib.SVD_U(self)
    def V(self): return _QuantLib.SVD_V(self)
    def S(self): return _QuantLib.SVD_S(self)
    def singularValues(self): return _QuantLib.SVD_singularValues(self)
    __swig_destroy__ = _QuantLib.delete_SVD
    __del__ = lambda self : None;
SVD_swigregister = _QuantLib.SVD_swigregister
SVD_swigregister(SVD)

class Quote(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Quote___deref__(self)
    def __nonzero__(self): return _QuantLib.Quote___nonzero__(self)
    def asObservable(self): return _QuantLib.Quote_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_Quote()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Quote
    __del__ = lambda self : None;
    def value(self): return _QuantLib.Quote_value(self)
Quote_swigregister = _QuantLib.Quote_swigregister
Quote_swigregister(Quote)

class QuoteHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_QuoteHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.QuoteHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.QuoteHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.QuoteHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandle
    __del__ = lambda self : None;
    def value(self): return _QuantLib.QuoteHandle_value(self)
QuoteHandle_swigregister = _QuantLib.QuoteHandle_swigregister
QuoteHandle_swigregister(QuoteHandle)

class RelinkableQuoteHandle(QuoteHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableQuoteHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableQuoteHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandle
    __del__ = lambda self : None;
RelinkableQuoteHandle_swigregister = _QuantLib.RelinkableQuoteHandle_swigregister
RelinkableQuoteHandle_swigregister(RelinkableQuoteHandle)

class SimpleQuote(Quote):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SimpleQuote(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args): return _QuantLib.SimpleQuote_setValue(self, *args)
    __swig_destroy__ = _QuantLib.delete_SimpleQuote
    __del__ = lambda self : None;
SimpleQuote_swigregister = _QuantLib.SimpleQuote_swigregister
SimpleQuote_swigregister(SimpleQuote)

class DerivedQuote(Quote):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DerivedQuote(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DerivedQuote
    __del__ = lambda self : None;
DerivedQuote_swigregister = _QuantLib.DerivedQuote_swigregister
DerivedQuote_swigregister(DerivedQuote)

class CompositeQuote(Quote):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CompositeQuote(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CompositeQuote
    __del__ = lambda self : None;
CompositeQuote_swigregister = _QuantLib.CompositeQuote_swigregister
CompositeQuote_swigregister(CompositeQuote)

class QuoteVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.QuoteVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.QuoteVector___nonzero__(self)
    def __bool__(self): return _QuantLib.QuoteVector___bool__(self)
    def __len__(self): return _QuantLib.QuoteVector___len__(self)
    def pop(self): return _QuantLib.QuoteVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.QuoteVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.QuoteVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.QuoteVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.QuoteVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.QuoteVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.QuoteVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.QuoteVector_append(self, *args)
    def empty(self): return _QuantLib.QuoteVector_empty(self)
    def size(self): return _QuantLib.QuoteVector_size(self)
    def clear(self): return _QuantLib.QuoteVector_clear(self)
    def swap(self, *args): return _QuantLib.QuoteVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.QuoteVector_get_allocator(self)
    def begin(self): return _QuantLib.QuoteVector_begin(self)
    def end(self): return _QuantLib.QuoteVector_end(self)
    def rbegin(self): return _QuantLib.QuoteVector_rbegin(self)
    def rend(self): return _QuantLib.QuoteVector_rend(self)
    def pop_back(self): return _QuantLib.QuoteVector_pop_back(self)
    def erase(self, *args): return _QuantLib.QuoteVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_QuoteVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.QuoteVector_push_back(self, *args)
    def front(self): return _QuantLib.QuoteVector_front(self)
    def back(self): return _QuantLib.QuoteVector_back(self)
    def assign(self, *args): return _QuantLib.QuoteVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.QuoteVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.QuoteVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.QuoteVector_reserve(self, *args)
    def capacity(self): return _QuantLib.QuoteVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteVector
    __del__ = lambda self : None;
QuoteVector_swigregister = _QuantLib.QuoteVector_swigregister
QuoteVector_swigregister(QuoteVector)

class QuoteHandleVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.QuoteHandleVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.QuoteHandleVector___nonzero__(self)
    def __bool__(self): return _QuantLib.QuoteHandleVector___bool__(self)
    def __len__(self): return _QuantLib.QuoteHandleVector___len__(self)
    def pop(self): return _QuantLib.QuoteHandleVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.QuoteHandleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.QuoteHandleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.QuoteHandleVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.QuoteHandleVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.QuoteHandleVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.QuoteHandleVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.QuoteHandleVector_append(self, *args)
    def empty(self): return _QuantLib.QuoteHandleVector_empty(self)
    def size(self): return _QuantLib.QuoteHandleVector_size(self)
    def clear(self): return _QuantLib.QuoteHandleVector_clear(self)
    def swap(self, *args): return _QuantLib.QuoteHandleVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.QuoteHandleVector_get_allocator(self)
    def begin(self): return _QuantLib.QuoteHandleVector_begin(self)
    def end(self): return _QuantLib.QuoteHandleVector_end(self)
    def rbegin(self): return _QuantLib.QuoteHandleVector_rbegin(self)
    def rend(self): return _QuantLib.QuoteHandleVector_rend(self)
    def pop_back(self): return _QuantLib.QuoteHandleVector_pop_back(self)
    def erase(self, *args): return _QuantLib.QuoteHandleVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_QuoteHandleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.QuoteHandleVector_push_back(self, *args)
    def front(self): return _QuantLib.QuoteHandleVector_front(self)
    def back(self): return _QuantLib.QuoteHandleVector_back(self)
    def assign(self, *args): return _QuantLib.QuoteHandleVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.QuoteHandleVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.QuoteHandleVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.QuoteHandleVector_reserve(self, *args)
    def capacity(self): return _QuantLib.QuoteHandleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandleVector
    __del__ = lambda self : None;
QuoteHandleVector_swigregister = _QuantLib.QuoteHandleVector_swigregister
QuoteHandleVector_swigregister(QuoteHandleVector)

class RelinkableQuoteHandleVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.RelinkableQuoteHandleVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.RelinkableQuoteHandleVector___nonzero__(self)
    def __bool__(self): return _QuantLib.RelinkableQuoteHandleVector___bool__(self)
    def __len__(self): return _QuantLib.RelinkableQuoteHandleVector___len__(self)
    def pop(self): return _QuantLib.RelinkableQuoteHandleVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.RelinkableQuoteHandleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.RelinkableQuoteHandleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.RelinkableQuoteHandleVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.RelinkableQuoteHandleVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.RelinkableQuoteHandleVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.RelinkableQuoteHandleVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.RelinkableQuoteHandleVector_append(self, *args)
    def empty(self): return _QuantLib.RelinkableQuoteHandleVector_empty(self)
    def size(self): return _QuantLib.RelinkableQuoteHandleVector_size(self)
    def clear(self): return _QuantLib.RelinkableQuoteHandleVector_clear(self)
    def swap(self, *args): return _QuantLib.RelinkableQuoteHandleVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.RelinkableQuoteHandleVector_get_allocator(self)
    def begin(self): return _QuantLib.RelinkableQuoteHandleVector_begin(self)
    def end(self): return _QuantLib.RelinkableQuoteHandleVector_end(self)
    def rbegin(self): return _QuantLib.RelinkableQuoteHandleVector_rbegin(self)
    def rend(self): return _QuantLib.RelinkableQuoteHandleVector_rend(self)
    def pop_back(self): return _QuantLib.RelinkableQuoteHandleVector_pop_back(self)
    def erase(self, *args): return _QuantLib.RelinkableQuoteHandleVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableQuoteHandleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.RelinkableQuoteHandleVector_push_back(self, *args)
    def front(self): return _QuantLib.RelinkableQuoteHandleVector_front(self)
    def back(self): return _QuantLib.RelinkableQuoteHandleVector_back(self)
    def assign(self, *args): return _QuantLib.RelinkableQuoteHandleVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.RelinkableQuoteHandleVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.RelinkableQuoteHandleVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.RelinkableQuoteHandleVector_reserve(self, *args)
    def capacity(self): return _QuantLib.RelinkableQuoteHandleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandleVector
    __del__ = lambda self : None;
RelinkableQuoteHandleVector_swigregister = _QuantLib.RelinkableQuoteHandleVector_swigregister
RelinkableQuoteHandleVector_swigregister(RelinkableQuoteHandleVector)


def nullInt():
  return _QuantLib.nullInt()
nullInt = _QuantLib.nullInt

def nullDouble():
  return _QuantLib.nullDouble()
nullDouble = _QuantLib.nullDouble
class DayCounter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def dayCount(self, *args): return _QuantLib.DayCounter_dayCount(self, *args)
    def yearFraction(self, *args): return _QuantLib.DayCounter_yearFraction(self, *args)
    def __str__(self): return _QuantLib.DayCounter___str__(self)
    def __eq__(self, *args): return _QuantLib.DayCounter___eq__(self, *args)
    def __ne__(self, *args): return _QuantLib.DayCounter___ne__(self, *args)
    __swig_destroy__ = _QuantLib.delete_DayCounter
    __del__ = lambda self : None;
DayCounter_swigregister = _QuantLib.DayCounter_swigregister
DayCounter_swigregister(DayCounter)

class Actual360(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Actual360()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Actual360
    __del__ = lambda self : None;
Actual360_swigregister = _QuantLib.Actual360_swigregister
Actual360_swigregister(Actual360)

class Actual365Fixed(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Actual365Fixed()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Actual365Fixed
    __del__ = lambda self : None;
Actual365Fixed_swigregister = _QuantLib.Actual365Fixed_swigregister
Actual365Fixed_swigregister(Actual365Fixed)

class Thirty360(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    USA = _QuantLib.Thirty360_USA
    BondBasis = _QuantLib.Thirty360_BondBasis
    European = _QuantLib.Thirty360_European
    EurobondBasis = _QuantLib.Thirty360_EurobondBasis
    Italian = _QuantLib.Thirty360_Italian
    def __init__(self, *args): 
        this = _QuantLib.new_Thirty360(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Thirty360
    __del__ = lambda self : None;
Thirty360_swigregister = _QuantLib.Thirty360_swigregister
Thirty360_swigregister(Thirty360)

class ActualActual(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ISMA = _QuantLib.ActualActual_ISMA
    Bond = _QuantLib.ActualActual_Bond
    ISDA = _QuantLib.ActualActual_ISDA
    Historical = _QuantLib.ActualActual_Historical
    Actual365 = _QuantLib.ActualActual_Actual365
    AFB = _QuantLib.ActualActual_AFB
    Euro = _QuantLib.ActualActual_Euro
    def __init__(self, *args): 
        this = _QuantLib.new_ActualActual(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ActualActual
    __del__ = lambda self : None;
ActualActual_swigregister = _QuantLib.ActualActual_swigregister
ActualActual_swigregister(ActualActual)

class OneDayCounter(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_OneDayCounter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_OneDayCounter
    __del__ = lambda self : None;
OneDayCounter_swigregister = _QuantLib.OneDayCounter_swigregister
OneDayCounter_swigregister(OneDayCounter)

class SimpleDayCounter(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SimpleDayCounter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SimpleDayCounter
    __del__ = lambda self : None;
SimpleDayCounter_swigregister = _QuantLib.SimpleDayCounter_swigregister
SimpleDayCounter_swigregister(SimpleDayCounter)

class Business252(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Business252()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Business252
    __del__ = lambda self : None;
Business252_swigregister = _QuantLib.Business252_swigregister
Business252_swigregister(Business252)

Simple = _QuantLib.Simple
Compounded = _QuantLib.Compounded
Continuous = _QuantLib.Continuous
SimpleThenCompounded = _QuantLib.SimpleThenCompounded
class InterestRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InterestRate(*args)
        try: self.this.append(this)
        except: self.this = this
    def rate(self): return _QuantLib.InterestRate_rate(self)
    def dayCounter(self): return _QuantLib.InterestRate_dayCounter(self)
    def compounding(self): return _QuantLib.InterestRate_compounding(self)
    def frequency(self): return _QuantLib.InterestRate_frequency(self)
    def discountFactor(self, *args): return _QuantLib.InterestRate_discountFactor(self, *args)
    def compoundFactor(self, *args): return _QuantLib.InterestRate_compoundFactor(self, *args)
    impliedRate = staticmethod(_QuantLib.InterestRate_impliedRate)
    def equivalentRate(self, *args): return _QuantLib.InterestRate_equivalentRate(self, *args)
    def __str__(self): return _QuantLib.InterestRate___str__(self)
    __swig_destroy__ = _QuantLib.delete_InterestRate
    __del__ = lambda self : None;
InterestRate_swigregister = _QuantLib.InterestRate_swigregister
InterestRate_swigregister(InterestRate)

def InterestRate_impliedRate(*args):
  return _QuantLib.InterestRate_impliedRate(*args)
InterestRate_impliedRate = _QuantLib.InterestRate_impliedRate

Following = _QuantLib.Following
ModifiedFollowing = _QuantLib.ModifiedFollowing
Preceding = _QuantLib.Preceding
ModifiedPreceding = _QuantLib.ModifiedPreceding
Unadjusted = _QuantLib.Unadjusted
JoinHolidays = _QuantLib.JoinHolidays
JoinBusinessDays = _QuantLib.JoinBusinessDays
class Calendar(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def isBusinessDay(self, *args): return _QuantLib.Calendar_isBusinessDay(self, *args)
    def isHoliday(self, *args): return _QuantLib.Calendar_isHoliday(self, *args)
    def isEndOfMonth(self, *args): return _QuantLib.Calendar_isEndOfMonth(self, *args)
    def addHoliday(self, *args): return _QuantLib.Calendar_addHoliday(self, *args)
    def removeHoliday(self, *args): return _QuantLib.Calendar_removeHoliday(self, *args)
    def adjust(self, *args): return _QuantLib.Calendar_adjust(self, *args)
    def advance(self, *args): return _QuantLib.Calendar_advance(self, *args)
    def businessDaysBetween(self, *args): return _QuantLib.Calendar_businessDaysBetween(self, *args)
    def __str__(self): return _QuantLib.Calendar___str__(self)
    def __eq__(self, *args): return _QuantLib.Calendar___eq__(self, *args)
    def __ne__(self, *args): return _QuantLib.Calendar___ne__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Calendar
    __del__ = lambda self : None;
Calendar_swigregister = _QuantLib.Calendar_swigregister
Calendar_swigregister(Calendar)

class Argentina(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Merval = _QuantLib.Argentina_Merval
    def __init__(self, *args): 
        this = _QuantLib.new_Argentina(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Argentina
    __del__ = lambda self : None;
Argentina_swigregister = _QuantLib.Argentina_swigregister
Argentina_swigregister(Argentina)

class Australia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Australia()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Australia
    __del__ = lambda self : None;
Australia_swigregister = _QuantLib.Australia_swigregister
Australia_swigregister(Australia)

class Brazil(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Brazil_Settlement
    Exchange = _QuantLib.Brazil_Exchange
    def __init__(self, *args): 
        this = _QuantLib.new_Brazil(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Brazil
    __del__ = lambda self : None;
Brazil_swigregister = _QuantLib.Brazil_swigregister
Brazil_swigregister(Brazil)

class Canada(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Canada_Settlement
    TSX = _QuantLib.Canada_TSX
    def __init__(self, *args): 
        this = _QuantLib.new_Canada(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Canada
    __del__ = lambda self : None;
Canada_swigregister = _QuantLib.Canada_swigregister
Canada_swigregister(Canada)

class China(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_China()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_China
    __del__ = lambda self : None;
China_swigregister = _QuantLib.China_swigregister
China_swigregister(China)

class CzechRepublic(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    PSE = _QuantLib.CzechRepublic_PSE
    def __init__(self, *args): 
        this = _QuantLib.new_CzechRepublic(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CzechRepublic
    __del__ = lambda self : None;
CzechRepublic_swigregister = _QuantLib.CzechRepublic_swigregister
CzechRepublic_swigregister(CzechRepublic)

class Denmark(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Denmark()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Denmark
    __del__ = lambda self : None;
Denmark_swigregister = _QuantLib.Denmark_swigregister
Denmark_swigregister(Denmark)

class Finland(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Finland()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Finland
    __del__ = lambda self : None;
Finland_swigregister = _QuantLib.Finland_swigregister
Finland_swigregister(Finland)

class Germany(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Germany_Settlement
    FrankfurtStockExchange = _QuantLib.Germany_FrankfurtStockExchange
    Xetra = _QuantLib.Germany_Xetra
    Eurex = _QuantLib.Germany_Eurex
    def __init__(self, *args): 
        this = _QuantLib.new_Germany(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Germany
    __del__ = lambda self : None;
Germany_swigregister = _QuantLib.Germany_swigregister
Germany_swigregister(Germany)

class HongKong(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    HKEx = _QuantLib.HongKong_HKEx
    def __init__(self, *args): 
        this = _QuantLib.new_HongKong(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_HongKong
    __del__ = lambda self : None;
HongKong_swigregister = _QuantLib.HongKong_swigregister
HongKong_swigregister(HongKong)

class Hungary(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Hungary()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Hungary
    __del__ = lambda self : None;
Hungary_swigregister = _QuantLib.Hungary_swigregister
Hungary_swigregister(Hungary)

class Iceland(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ICEX = _QuantLib.Iceland_ICEX
    def __init__(self, *args): 
        this = _QuantLib.new_Iceland(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Iceland
    __del__ = lambda self : None;
Iceland_swigregister = _QuantLib.Iceland_swigregister
Iceland_swigregister(Iceland)

class India(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NSE = _QuantLib.India_NSE
    def __init__(self, *args): 
        this = _QuantLib.new_India(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_India
    __del__ = lambda self : None;
India_swigregister = _QuantLib.India_swigregister
India_swigregister(India)

class Indonesia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BEJ = _QuantLib.Indonesia_BEJ
    JSX = _QuantLib.Indonesia_JSX
    def __init__(self, *args): 
        this = _QuantLib.new_Indonesia(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Indonesia
    __del__ = lambda self : None;
Indonesia_swigregister = _QuantLib.Indonesia_swigregister
Indonesia_swigregister(Indonesia)

class Italy(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Italy_Settlement
    Exchange = _QuantLib.Italy_Exchange
    def __init__(self, *args): 
        this = _QuantLib.new_Italy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Italy
    __del__ = lambda self : None;
Italy_swigregister = _QuantLib.Italy_swigregister
Italy_swigregister(Italy)

class Japan(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Japan()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Japan
    __del__ = lambda self : None;
Japan_swigregister = _QuantLib.Japan_swigregister
Japan_swigregister(Japan)

class Mexico(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BMV = _QuantLib.Mexico_BMV
    def __init__(self, *args): 
        this = _QuantLib.new_Mexico(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Mexico
    __del__ = lambda self : None;
Mexico_swigregister = _QuantLib.Mexico_swigregister
Mexico_swigregister(Mexico)

class NewZealand(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NewZealand()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NewZealand
    __del__ = lambda self : None;
NewZealand_swigregister = _QuantLib.NewZealand_swigregister
NewZealand_swigregister(NewZealand)

class Norway(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Norway()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Norway
    __del__ = lambda self : None;
Norway_swigregister = _QuantLib.Norway_swigregister
Norway_swigregister(Norway)

class Poland(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Poland()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Poland
    __del__ = lambda self : None;
Poland_swigregister = _QuantLib.Poland_swigregister
Poland_swigregister(Poland)

class SaudiArabia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Tadawul = _QuantLib.SaudiArabia_Tadawul
    def __init__(self, *args): 
        this = _QuantLib.new_SaudiArabia(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SaudiArabia
    __del__ = lambda self : None;
SaudiArabia_swigregister = _QuantLib.SaudiArabia_swigregister
SaudiArabia_swigregister(SaudiArabia)

class Singapore(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SGX = _QuantLib.Singapore_SGX
    def __init__(self, *args): 
        this = _QuantLib.new_Singapore(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Singapore
    __del__ = lambda self : None;
Singapore_swigregister = _QuantLib.Singapore_swigregister
Singapore_swigregister(Singapore)

class Slovakia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BSSE = _QuantLib.Slovakia_BSSE
    def __init__(self, *args): 
        this = _QuantLib.new_Slovakia(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Slovakia
    __del__ = lambda self : None;
Slovakia_swigregister = _QuantLib.Slovakia_swigregister
Slovakia_swigregister(Slovakia)

class SouthAfrica(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SouthAfrica()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SouthAfrica
    __del__ = lambda self : None;
SouthAfrica_swigregister = _QuantLib.SouthAfrica_swigregister
SouthAfrica_swigregister(SouthAfrica)

class SouthKorea(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.SouthKorea_Settlement
    KRX = _QuantLib.SouthKorea_KRX
    def __init__(self, *args): 
        this = _QuantLib.new_SouthKorea(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SouthKorea
    __del__ = lambda self : None;
SouthKorea_swigregister = _QuantLib.SouthKorea_swigregister
SouthKorea_swigregister(SouthKorea)

class Sweden(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Sweden()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Sweden
    __del__ = lambda self : None;
Sweden_swigregister = _QuantLib.Sweden_swigregister
Sweden_swigregister(Sweden)

class Switzerland(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Switzerland()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Switzerland
    __del__ = lambda self : None;
Switzerland_swigregister = _QuantLib.Switzerland_swigregister
Switzerland_swigregister(Switzerland)

class Taiwan(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    TSEC = _QuantLib.Taiwan_TSEC
    def __init__(self, *args): 
        this = _QuantLib.new_Taiwan(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Taiwan
    __del__ = lambda self : None;
Taiwan_swigregister = _QuantLib.Taiwan_swigregister
Taiwan_swigregister(Taiwan)

class TARGET(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_TARGET()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TARGET
    __del__ = lambda self : None;
TARGET_swigregister = _QuantLib.TARGET_swigregister
TARGET_swigregister(TARGET)

class Turkey(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Turkey()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Turkey
    __del__ = lambda self : None;
Turkey_swigregister = _QuantLib.Turkey_swigregister
Turkey_swigregister(Turkey)

class Ukraine(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    USE = _QuantLib.Ukraine_USE
    def __init__(self, *args): 
        this = _QuantLib.new_Ukraine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Ukraine
    __del__ = lambda self : None;
Ukraine_swigregister = _QuantLib.Ukraine_swigregister
Ukraine_swigregister(Ukraine)

class UnitedKingdom(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.UnitedKingdom_Settlement
    Exchange = _QuantLib.UnitedKingdom_Exchange
    Metals = _QuantLib.UnitedKingdom_Metals
    def __init__(self, *args): 
        this = _QuantLib.new_UnitedKingdom(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_UnitedKingdom
    __del__ = lambda self : None;
UnitedKingdom_swigregister = _QuantLib.UnitedKingdom_swigregister
UnitedKingdom_swigregister(UnitedKingdom)

class UnitedStates(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.UnitedStates_Settlement
    NYSE = _QuantLib.UnitedStates_NYSE
    GovernmentBond = _QuantLib.UnitedStates_GovernmentBond
    NERC = _QuantLib.UnitedStates_NERC
    def __init__(self, *args): 
        this = _QuantLib.new_UnitedStates(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_UnitedStates
    __del__ = lambda self : None;
UnitedStates_swigregister = _QuantLib.UnitedStates_swigregister
UnitedStates_swigregister(UnitedStates)

class NullCalendar(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NullCalendar()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NullCalendar
    __del__ = lambda self : None;
NullCalendar_swigregister = _QuantLib.NullCalendar_swigregister
NullCalendar_swigregister(NullCalendar)

class JointCalendar(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_JointCalendar(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_JointCalendar
    __del__ = lambda self : None;
JointCalendar_swigregister = _QuantLib.JointCalendar_swigregister
JointCalendar_swigregister(JointCalendar)

class Rounding(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Rounding()
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.Rounding___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Rounding
    __del__ = lambda self : None;
Rounding_swigregister = _QuantLib.Rounding_swigregister
Rounding_swigregister(Rounding)

class UpRounding(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_UpRounding(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_UpRounding
    __del__ = lambda self : None;
UpRounding_swigregister = _QuantLib.UpRounding_swigregister
UpRounding_swigregister(UpRounding)

class DownRounding(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DownRounding(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DownRounding
    __del__ = lambda self : None;
DownRounding_swigregister = _QuantLib.DownRounding_swigregister
DownRounding_swigregister(DownRounding)

class ClosestRounding(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ClosestRounding(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ClosestRounding
    __del__ = lambda self : None;
ClosestRounding_swigregister = _QuantLib.ClosestRounding_swigregister
ClosestRounding_swigregister(ClosestRounding)

class CeilingTruncation(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CeilingTruncation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CeilingTruncation
    __del__ = lambda self : None;
CeilingTruncation_swigregister = _QuantLib.CeilingTruncation_swigregister
CeilingTruncation_swigregister(CeilingTruncation)

class FloorTruncation(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FloorTruncation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FloorTruncation
    __del__ = lambda self : None;
FloorTruncation_swigregister = _QuantLib.FloorTruncation_swigregister
FloorTruncation_swigregister(FloorTruncation)

class Currency(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def name(self): return _QuantLib.Currency_name(self)
    def code(self): return _QuantLib.Currency_code(self)
    def numericCode(self): return _QuantLib.Currency_numericCode(self)
    def symbol(self): return _QuantLib.Currency_symbol(self)
    def fractionSymbol(self): return _QuantLib.Currency_fractionSymbol(self)
    def fractionsPerUnit(self): return _QuantLib.Currency_fractionsPerUnit(self)
    def rounding(self): return _QuantLib.Currency_rounding(self)
    def format(self): return _QuantLib.Currency_format(self)
    def __nonzero__(self): return _QuantLib.Currency___nonzero__(self)
    def triangulationCurrency(self): return _QuantLib.Currency_triangulationCurrency(self)
    def __str__(self): return _QuantLib.Currency___str__(self)
    def __eq__(self, *args): return _QuantLib.Currency___eq__(self, *args)
    def __ne__(self, *args): return _QuantLib.Currency___ne__(self, *args)
    def __mul__(self, *args): return _QuantLib.Currency___mul__(self, *args)
    def __rmul__(self, *args): return _QuantLib.Currency___rmul__(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Currency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Currency
    __del__ = lambda self : None;
Currency_swigregister = _QuantLib.Currency_swigregister
Currency_swigregister(Currency)

class ARSCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ARSCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ARSCurrency
    __del__ = lambda self : None;
ARSCurrency_swigregister = _QuantLib.ARSCurrency_swigregister
ARSCurrency_swigregister(ARSCurrency)

class ATSCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ATSCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ATSCurrency
    __del__ = lambda self : None;
ATSCurrency_swigregister = _QuantLib.ATSCurrency_swigregister
ATSCurrency_swigregister(ATSCurrency)

class AUDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_AUDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AUDCurrency
    __del__ = lambda self : None;
AUDCurrency_swigregister = _QuantLib.AUDCurrency_swigregister
AUDCurrency_swigregister(AUDCurrency)

class BDTCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BDTCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BDTCurrency
    __del__ = lambda self : None;
BDTCurrency_swigregister = _QuantLib.BDTCurrency_swigregister
BDTCurrency_swigregister(BDTCurrency)

class BEFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BEFCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BEFCurrency
    __del__ = lambda self : None;
BEFCurrency_swigregister = _QuantLib.BEFCurrency_swigregister
BEFCurrency_swigregister(BEFCurrency)

class BGLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BGLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BGLCurrency
    __del__ = lambda self : None;
BGLCurrency_swigregister = _QuantLib.BGLCurrency_swigregister
BGLCurrency_swigregister(BGLCurrency)

class BRLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BRLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BRLCurrency
    __del__ = lambda self : None;
BRLCurrency_swigregister = _QuantLib.BRLCurrency_swigregister
BRLCurrency_swigregister(BRLCurrency)

class BYRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BYRCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BYRCurrency
    __del__ = lambda self : None;
BYRCurrency_swigregister = _QuantLib.BYRCurrency_swigregister
BYRCurrency_swigregister(BYRCurrency)

class CADCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CADCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CADCurrency
    __del__ = lambda self : None;
CADCurrency_swigregister = _QuantLib.CADCurrency_swigregister
CADCurrency_swigregister(CADCurrency)

class CHFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CHFCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CHFCurrency
    __del__ = lambda self : None;
CHFCurrency_swigregister = _QuantLib.CHFCurrency_swigregister
CHFCurrency_swigregister(CHFCurrency)

class CLPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CLPCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CLPCurrency
    __del__ = lambda self : None;
CLPCurrency_swigregister = _QuantLib.CLPCurrency_swigregister
CLPCurrency_swigregister(CLPCurrency)

class CNYCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CNYCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CNYCurrency
    __del__ = lambda self : None;
CNYCurrency_swigregister = _QuantLib.CNYCurrency_swigregister
CNYCurrency_swigregister(CNYCurrency)

class COPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_COPCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_COPCurrency
    __del__ = lambda self : None;
COPCurrency_swigregister = _QuantLib.COPCurrency_swigregister
COPCurrency_swigregister(COPCurrency)

class CYPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CYPCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CYPCurrency
    __del__ = lambda self : None;
CYPCurrency_swigregister = _QuantLib.CYPCurrency_swigregister
CYPCurrency_swigregister(CYPCurrency)

class CZKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CZKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CZKCurrency
    __del__ = lambda self : None;
CZKCurrency_swigregister = _QuantLib.CZKCurrency_swigregister
CZKCurrency_swigregister(CZKCurrency)

class DEMCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_DEMCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DEMCurrency
    __del__ = lambda self : None;
DEMCurrency_swigregister = _QuantLib.DEMCurrency_swigregister
DEMCurrency_swigregister(DEMCurrency)

class DKKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_DKKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DKKCurrency
    __del__ = lambda self : None;
DKKCurrency_swigregister = _QuantLib.DKKCurrency_swigregister
DKKCurrency_swigregister(DKKCurrency)

class EEKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_EEKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EEKCurrency
    __del__ = lambda self : None;
EEKCurrency_swigregister = _QuantLib.EEKCurrency_swigregister
EEKCurrency_swigregister(EEKCurrency)

class ESPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ESPCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ESPCurrency
    __del__ = lambda self : None;
ESPCurrency_swigregister = _QuantLib.ESPCurrency_swigregister
ESPCurrency_swigregister(ESPCurrency)

class EURCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_EURCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURCurrency
    __del__ = lambda self : None;
EURCurrency_swigregister = _QuantLib.EURCurrency_swigregister
EURCurrency_swigregister(EURCurrency)

class FIMCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_FIMCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FIMCurrency
    __del__ = lambda self : None;
FIMCurrency_swigregister = _QuantLib.FIMCurrency_swigregister
FIMCurrency_swigregister(FIMCurrency)

class FRFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_FRFCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FRFCurrency
    __del__ = lambda self : None;
FRFCurrency_swigregister = _QuantLib.FRFCurrency_swigregister
FRFCurrency_swigregister(FRFCurrency)

class GBPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_GBPCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_GBPCurrency
    __del__ = lambda self : None;
GBPCurrency_swigregister = _QuantLib.GBPCurrency_swigregister
GBPCurrency_swigregister(GBPCurrency)

class GRDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_GRDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_GRDCurrency
    __del__ = lambda self : None;
GRDCurrency_swigregister = _QuantLib.GRDCurrency_swigregister
GRDCurrency_swigregister(GRDCurrency)

class HKDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_HKDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_HKDCurrency
    __del__ = lambda self : None;
HKDCurrency_swigregister = _QuantLib.HKDCurrency_swigregister
HKDCurrency_swigregister(HKDCurrency)

class HUFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_HUFCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_HUFCurrency
    __del__ = lambda self : None;
HUFCurrency_swigregister = _QuantLib.HUFCurrency_swigregister
HUFCurrency_swigregister(HUFCurrency)

class IEPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_IEPCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_IEPCurrency
    __del__ = lambda self : None;
IEPCurrency_swigregister = _QuantLib.IEPCurrency_swigregister
IEPCurrency_swigregister(IEPCurrency)

class ILSCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ILSCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ILSCurrency
    __del__ = lambda self : None;
ILSCurrency_swigregister = _QuantLib.ILSCurrency_swigregister
ILSCurrency_swigregister(ILSCurrency)

class INRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_INRCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_INRCurrency
    __del__ = lambda self : None;
INRCurrency_swigregister = _QuantLib.INRCurrency_swigregister
INRCurrency_swigregister(INRCurrency)

class IQDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_IQDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_IQDCurrency
    __del__ = lambda self : None;
IQDCurrency_swigregister = _QuantLib.IQDCurrency_swigregister
IQDCurrency_swigregister(IQDCurrency)

class IRRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_IRRCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_IRRCurrency
    __del__ = lambda self : None;
IRRCurrency_swigregister = _QuantLib.IRRCurrency_swigregister
IRRCurrency_swigregister(IRRCurrency)

class ISKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ISKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ISKCurrency
    __del__ = lambda self : None;
ISKCurrency_swigregister = _QuantLib.ISKCurrency_swigregister
ISKCurrency_swigregister(ISKCurrency)

class ITLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ITLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ITLCurrency
    __del__ = lambda self : None;
ITLCurrency_swigregister = _QuantLib.ITLCurrency_swigregister
ITLCurrency_swigregister(ITLCurrency)

class JPYCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_JPYCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_JPYCurrency
    __del__ = lambda self : None;
JPYCurrency_swigregister = _QuantLib.JPYCurrency_swigregister
JPYCurrency_swigregister(JPYCurrency)

class KRWCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_KRWCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_KRWCurrency
    __del__ = lambda self : None;
KRWCurrency_swigregister = _QuantLib.KRWCurrency_swigregister
KRWCurrency_swigregister(KRWCurrency)

class KWDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_KWDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_KWDCurrency
    __del__ = lambda self : None;
KWDCurrency_swigregister = _QuantLib.KWDCurrency_swigregister
KWDCurrency_swigregister(KWDCurrency)

class LTLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_LTLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_LTLCurrency
    __del__ = lambda self : None;
LTLCurrency_swigregister = _QuantLib.LTLCurrency_swigregister
LTLCurrency_swigregister(LTLCurrency)

class LUFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_LUFCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_LUFCurrency
    __del__ = lambda self : None;
LUFCurrency_swigregister = _QuantLib.LUFCurrency_swigregister
LUFCurrency_swigregister(LUFCurrency)

class LVLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_LVLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_LVLCurrency
    __del__ = lambda self : None;
LVLCurrency_swigregister = _QuantLib.LVLCurrency_swigregister
LVLCurrency_swigregister(LVLCurrency)

class MTLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_MTLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MTLCurrency
    __del__ = lambda self : None;
MTLCurrency_swigregister = _QuantLib.MTLCurrency_swigregister
MTLCurrency_swigregister(MTLCurrency)

class MXNCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_MXNCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MXNCurrency
    __del__ = lambda self : None;
MXNCurrency_swigregister = _QuantLib.MXNCurrency_swigregister
MXNCurrency_swigregister(MXNCurrency)

class NLGCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NLGCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NLGCurrency
    __del__ = lambda self : None;
NLGCurrency_swigregister = _QuantLib.NLGCurrency_swigregister
NLGCurrency_swigregister(NLGCurrency)

class NOKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NOKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NOKCurrency
    __del__ = lambda self : None;
NOKCurrency_swigregister = _QuantLib.NOKCurrency_swigregister
NOKCurrency_swigregister(NOKCurrency)

class NPRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NPRCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NPRCurrency
    __del__ = lambda self : None;
NPRCurrency_swigregister = _QuantLib.NPRCurrency_swigregister
NPRCurrency_swigregister(NPRCurrency)

class NZDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NZDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NZDCurrency
    __del__ = lambda self : None;
NZDCurrency_swigregister = _QuantLib.NZDCurrency_swigregister
NZDCurrency_swigregister(NZDCurrency)

class PEHCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PEHCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PEHCurrency
    __del__ = lambda self : None;
PEHCurrency_swigregister = _QuantLib.PEHCurrency_swigregister
PEHCurrency_swigregister(PEHCurrency)

class PEICurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PEICurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PEICurrency
    __del__ = lambda self : None;
PEICurrency_swigregister = _QuantLib.PEICurrency_swigregister
PEICurrency_swigregister(PEICurrency)

class PENCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PENCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PENCurrency
    __del__ = lambda self : None;
PENCurrency_swigregister = _QuantLib.PENCurrency_swigregister
PENCurrency_swigregister(PENCurrency)

class PKRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PKRCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PKRCurrency
    __del__ = lambda self : None;
PKRCurrency_swigregister = _QuantLib.PKRCurrency_swigregister
PKRCurrency_swigregister(PKRCurrency)

class PLNCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PLNCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PLNCurrency
    __del__ = lambda self : None;
PLNCurrency_swigregister = _QuantLib.PLNCurrency_swigregister
PLNCurrency_swigregister(PLNCurrency)

class PTECurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PTECurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PTECurrency
    __del__ = lambda self : None;
PTECurrency_swigregister = _QuantLib.PTECurrency_swigregister
PTECurrency_swigregister(PTECurrency)

class ROLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ROLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ROLCurrency
    __del__ = lambda self : None;
ROLCurrency_swigregister = _QuantLib.ROLCurrency_swigregister
ROLCurrency_swigregister(ROLCurrency)

class RONCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_RONCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_RONCurrency
    __del__ = lambda self : None;
RONCurrency_swigregister = _QuantLib.RONCurrency_swigregister
RONCurrency_swigregister(RONCurrency)

class SARCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SARCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SARCurrency
    __del__ = lambda self : None;
SARCurrency_swigregister = _QuantLib.SARCurrency_swigregister
SARCurrency_swigregister(SARCurrency)

class SEKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SEKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SEKCurrency
    __del__ = lambda self : None;
SEKCurrency_swigregister = _QuantLib.SEKCurrency_swigregister
SEKCurrency_swigregister(SEKCurrency)

class SGDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SGDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SGDCurrency
    __del__ = lambda self : None;
SGDCurrency_swigregister = _QuantLib.SGDCurrency_swigregister
SGDCurrency_swigregister(SGDCurrency)

class SITCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SITCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SITCurrency
    __del__ = lambda self : None;
SITCurrency_swigregister = _QuantLib.SITCurrency_swigregister
SITCurrency_swigregister(SITCurrency)

class SKKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SKKCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SKKCurrency
    __del__ = lambda self : None;
SKKCurrency_swigregister = _QuantLib.SKKCurrency_swigregister
SKKCurrency_swigregister(SKKCurrency)

class THBCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_THBCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_THBCurrency
    __del__ = lambda self : None;
THBCurrency_swigregister = _QuantLib.THBCurrency_swigregister
THBCurrency_swigregister(THBCurrency)

class TRLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_TRLCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TRLCurrency
    __del__ = lambda self : None;
TRLCurrency_swigregister = _QuantLib.TRLCurrency_swigregister
TRLCurrency_swigregister(TRLCurrency)

class TRYCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_TRYCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TRYCurrency
    __del__ = lambda self : None;
TRYCurrency_swigregister = _QuantLib.TRYCurrency_swigregister
TRYCurrency_swigregister(TRYCurrency)

class TTDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_TTDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TTDCurrency
    __del__ = lambda self : None;
TTDCurrency_swigregister = _QuantLib.TTDCurrency_swigregister
TTDCurrency_swigregister(TTDCurrency)

class TWDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_TWDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TWDCurrency
    __del__ = lambda self : None;
TWDCurrency_swigregister = _QuantLib.TWDCurrency_swigregister
TWDCurrency_swigregister(TWDCurrency)

class USDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_USDCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_USDCurrency
    __del__ = lambda self : None;
USDCurrency_swigregister = _QuantLib.USDCurrency_swigregister
USDCurrency_swigregister(USDCurrency)

class VEBCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_VEBCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_VEBCurrency
    __del__ = lambda self : None;
VEBCurrency_swigregister = _QuantLib.VEBCurrency_swigregister
VEBCurrency_swigregister(VEBCurrency)

class ZARCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ZARCurrency()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ZARCurrency
    __del__ = lambda self : None;
ZARCurrency_swigregister = _QuantLib.ZARCurrency_swigregister
ZARCurrency_swigregister(ZARCurrency)

class LinearInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LinearInterpolation(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.LinearInterpolation___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_LinearInterpolation
    __del__ = lambda self : None;
LinearInterpolation_swigregister = _QuantLib.LinearInterpolation_swigregister
LinearInterpolation_swigregister(LinearInterpolation)

class LogLinearInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LogLinearInterpolation(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.LogLinearInterpolation___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_LogLinearInterpolation
    __del__ = lambda self : None;
LogLinearInterpolation_swigregister = _QuantLib.LogLinearInterpolation_swigregister
LogLinearInterpolation_swigregister(LogLinearInterpolation)

class BackwardFlatInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BackwardFlatInterpolation(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.BackwardFlatInterpolation___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_BackwardFlatInterpolation
    __del__ = lambda self : None;
BackwardFlatInterpolation_swigregister = _QuantLib.BackwardFlatInterpolation_swigregister
BackwardFlatInterpolation_swigregister(BackwardFlatInterpolation)

class ForwardFlatInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ForwardFlatInterpolation(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.ForwardFlatInterpolation___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_ForwardFlatInterpolation
    __del__ = lambda self : None;
ForwardFlatInterpolation_swigregister = _QuantLib.ForwardFlatInterpolation_swigregister
ForwardFlatInterpolation_swigregister(ForwardFlatInterpolation)

class CubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CubicNaturalSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.CubicNaturalSpline___call__(self, *args)
    def derivative(self, *args): return _QuantLib.CubicNaturalSpline_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.CubicNaturalSpline_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.CubicNaturalSpline_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_CubicNaturalSpline
    __del__ = lambda self : None;
CubicNaturalSpline_swigregister = _QuantLib.CubicNaturalSpline_swigregister
CubicNaturalSpline_swigregister(CubicNaturalSpline)

class LogCubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LogCubicNaturalSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.LogCubicNaturalSpline___call__(self, *args)
    def derivative(self, *args): return _QuantLib.LogCubicNaturalSpline_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.LogCubicNaturalSpline_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.LogCubicNaturalSpline_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_LogCubicNaturalSpline
    __del__ = lambda self : None;
LogCubicNaturalSpline_swigregister = _QuantLib.LogCubicNaturalSpline_swigregister
LogCubicNaturalSpline_swigregister(LogCubicNaturalSpline)

class MonotonicCubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MonotonicCubicNaturalSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.MonotonicCubicNaturalSpline___call__(self, *args)
    def derivative(self, *args): return _QuantLib.MonotonicCubicNaturalSpline_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.MonotonicCubicNaturalSpline_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.MonotonicCubicNaturalSpline_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicNaturalSpline
    __del__ = lambda self : None;
MonotonicCubicNaturalSpline_swigregister = _QuantLib.MonotonicCubicNaturalSpline_swigregister
MonotonicCubicNaturalSpline_swigregister(MonotonicCubicNaturalSpline)

class MonotonicLogCubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MonotonicLogCubicNaturalSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.MonotonicLogCubicNaturalSpline___call__(self, *args)
    def derivative(self, *args): return _QuantLib.MonotonicLogCubicNaturalSpline_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.MonotonicLogCubicNaturalSpline_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.MonotonicLogCubicNaturalSpline_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubicNaturalSpline
    __del__ = lambda self : None;
MonotonicLogCubicNaturalSpline_swigregister = _QuantLib.MonotonicLogCubicNaturalSpline_swigregister
MonotonicLogCubicNaturalSpline_swigregister(MonotonicLogCubicNaturalSpline)

class KrugerCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_KrugerCubic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.KrugerCubic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.KrugerCubic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.KrugerCubic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.KrugerCubic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_KrugerCubic
    __del__ = lambda self : None;
KrugerCubic_swigregister = _QuantLib.KrugerCubic_swigregister
KrugerCubic_swigregister(KrugerCubic)

class KrugerLogCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_KrugerLogCubic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.KrugerLogCubic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.KrugerLogCubic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.KrugerLogCubic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.KrugerLogCubic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_KrugerLogCubic
    __del__ = lambda self : None;
KrugerLogCubic_swigregister = _QuantLib.KrugerLogCubic_swigregister
KrugerLogCubic_swigregister(KrugerLogCubic)

class FritschButlandCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FritschButlandCubic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.FritschButlandCubic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.FritschButlandCubic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.FritschButlandCubic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.FritschButlandCubic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_FritschButlandCubic
    __del__ = lambda self : None;
FritschButlandCubic_swigregister = _QuantLib.FritschButlandCubic_swigregister
FritschButlandCubic_swigregister(FritschButlandCubic)

class FritschButlandLogCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FritschButlandLogCubic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.FritschButlandLogCubic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.FritschButlandLogCubic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.FritschButlandLogCubic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.FritschButlandLogCubic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_FritschButlandLogCubic
    __del__ = lambda self : None;
FritschButlandLogCubic_swigregister = _QuantLib.FritschButlandLogCubic_swigregister
FritschButlandLogCubic_swigregister(FritschButlandLogCubic)

class Parabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Parabolic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.Parabolic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.Parabolic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.Parabolic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.Parabolic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_Parabolic
    __del__ = lambda self : None;
Parabolic_swigregister = _QuantLib.Parabolic_swigregister
Parabolic_swigregister(Parabolic)

class LogParabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LogParabolic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.LogParabolic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.LogParabolic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.LogParabolic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.LogParabolic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_LogParabolic
    __del__ = lambda self : None;
LogParabolic_swigregister = _QuantLib.LogParabolic_swigregister
LogParabolic_swigregister(LogParabolic)

class MonotonicParabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MonotonicParabolic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.MonotonicParabolic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.MonotonicParabolic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.MonotonicParabolic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.MonotonicParabolic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_MonotonicParabolic
    __del__ = lambda self : None;
MonotonicParabolic_swigregister = _QuantLib.MonotonicParabolic_swigregister
MonotonicParabolic_swigregister(MonotonicParabolic)

class MonotonicLogParabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MonotonicLogParabolic(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.MonotonicLogParabolic___call__(self, *args)
    def derivative(self, *args): return _QuantLib.MonotonicLogParabolic_derivative(self, *args)
    def secondDerivative(self, *args): return _QuantLib.MonotonicLogParabolic_secondDerivative(self, *args)
    def primitive(self, *args): return _QuantLib.MonotonicLogParabolic_primitive(self, *args)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogParabolic
    __del__ = lambda self : None;
MonotonicLogParabolic_swigregister = _QuantLib.MonotonicLogParabolic_swigregister
MonotonicLogParabolic_swigregister(MonotonicLogParabolic)

class BilinearInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BilinearInterpolation(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.BilinearInterpolation___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_BilinearInterpolation
    __del__ = lambda self : None;
BilinearInterpolation_swigregister = _QuantLib.BilinearInterpolation_swigregister
BilinearInterpolation_swigregister(BilinearInterpolation)

class BicubicSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BicubicSpline(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.BicubicSpline___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_BicubicSpline
    __del__ = lambda self : None;
BicubicSpline_swigregister = _QuantLib.BicubicSpline_swigregister
BicubicSpline_swigregister(BicubicSpline)

class BackwardFlat(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BackwardFlat()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BackwardFlat
    __del__ = lambda self : None;
BackwardFlat_swigregister = _QuantLib.BackwardFlat_swigregister
BackwardFlat_swigregister(BackwardFlat)

class ForwardFlat(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ForwardFlat()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardFlat
    __del__ = lambda self : None;
ForwardFlat_swigregister = _QuantLib.ForwardFlat_swigregister
ForwardFlat_swigregister(ForwardFlat)

class Linear(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Linear()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Linear
    __del__ = lambda self : None;
Linear_swigregister = _QuantLib.Linear_swigregister
Linear_swigregister(Linear)

class LogLinear(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_LogLinear()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_LogLinear
    __del__ = lambda self : None;
LogLinear_swigregister = _QuantLib.LogLinear_swigregister
LogLinear_swigregister(LogLinear)

class Cubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Cubic()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Cubic
    __del__ = lambda self : None;
Cubic_swigregister = _QuantLib.Cubic_swigregister
Cubic_swigregister(Cubic)

class YieldTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.YieldTermStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.YieldTermStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.YieldTermStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_YieldTermStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_YieldTermStructure
    __del__ = lambda self : None;
    def dayCounter(self): return _QuantLib.YieldTermStructure_dayCounter(self)
    def calendar(self): return _QuantLib.YieldTermStructure_calendar(self)
    def referenceDate(self): return _QuantLib.YieldTermStructure_referenceDate(self)
    def maxDate(self): return _QuantLib.YieldTermStructure_maxDate(self)
    def maxTime(self): return _QuantLib.YieldTermStructure_maxTime(self)
    def discount(self, *args): return _QuantLib.YieldTermStructure_discount(self, *args)
    def zeroRate(self, *args): return _QuantLib.YieldTermStructure_zeroRate(self, *args)
    def forwardRate(self, *args): return _QuantLib.YieldTermStructure_forwardRate(self, *args)
    def enableExtrapolation(self): return _QuantLib.YieldTermStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.YieldTermStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.YieldTermStructure_allowsExtrapolation(self)
YieldTermStructure_swigregister = _QuantLib.YieldTermStructure_swigregister
YieldTermStructure_swigregister(YieldTermStructure)

class YieldTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_YieldTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.YieldTermStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.YieldTermStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.YieldTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YieldTermStructureHandle
    __del__ = lambda self : None;
    def dayCounter(self): return _QuantLib.YieldTermStructureHandle_dayCounter(self)
    def calendar(self): return _QuantLib.YieldTermStructureHandle_calendar(self)
    def referenceDate(self): return _QuantLib.YieldTermStructureHandle_referenceDate(self)
    def maxDate(self): return _QuantLib.YieldTermStructureHandle_maxDate(self)
    def maxTime(self): return _QuantLib.YieldTermStructureHandle_maxTime(self)
    def discount(self, *args): return _QuantLib.YieldTermStructureHandle_discount(self, *args)
    def zeroRate(self, *args): return _QuantLib.YieldTermStructureHandle_zeroRate(self, *args)
    def forwardRate(self, *args): return _QuantLib.YieldTermStructureHandle_forwardRate(self, *args)
    def enableExtrapolation(self): return _QuantLib.YieldTermStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.YieldTermStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.YieldTermStructureHandle_allowsExtrapolation(self)
YieldTermStructureHandle_swigregister = _QuantLib.YieldTermStructureHandle_swigregister
YieldTermStructureHandle_swigregister(YieldTermStructureHandle)

class RelinkableYieldTermStructureHandle(YieldTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableYieldTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableYieldTermStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableYieldTermStructureHandle
    __del__ = lambda self : None;
RelinkableYieldTermStructureHandle_swigregister = _QuantLib.RelinkableYieldTermStructureHandle_swigregister
RelinkableYieldTermStructureHandle_swigregister(RelinkableYieldTermStructureHandle)

class ImpliedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ImpliedTermStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ImpliedTermStructure
    __del__ = lambda self : None;
ImpliedTermStructure_swigregister = _QuantLib.ImpliedTermStructure_swigregister
ImpliedTermStructure_swigregister(ImpliedTermStructure)

class ZeroSpreadedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ZeroSpreadedTermStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroSpreadedTermStructure
    __del__ = lambda self : None;
ZeroSpreadedTermStructure_swigregister = _QuantLib.ZeroSpreadedTermStructure_swigregister
ZeroSpreadedTermStructure_swigregister(ZeroSpreadedTermStructure)

class ForwardSpreadedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ForwardSpreadedTermStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardSpreadedTermStructure
    __del__ = lambda self : None;
ForwardSpreadedTermStructure_swigregister = _QuantLib.ForwardSpreadedTermStructure_swigregister
ForwardSpreadedTermStructure_swigregister(ForwardSpreadedTermStructure)

class FlatForward(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FlatForward(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FlatForward
    __del__ = lambda self : None;
FlatForward_swigregister = _QuantLib.FlatForward_swigregister
FlatForward_swigregister(FlatForward)

class BlackVolTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.BlackVolTermStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.BlackVolTermStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.BlackVolTermStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_BlackVolTermStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructure
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.BlackVolTermStructure_referenceDate(self)
    def dayCounter(self): return _QuantLib.BlackVolTermStructure_dayCounter(self)
    def calendar(self): return _QuantLib.BlackVolTermStructure_calendar(self)
    def maxDate(self): return _QuantLib.BlackVolTermStructure_maxDate(self)
    def maxTime(self): return _QuantLib.BlackVolTermStructure_maxTime(self)
    def minStrike(self): return _QuantLib.BlackVolTermStructure_minStrike(self)
    def maxStrike(self): return _QuantLib.BlackVolTermStructure_maxStrike(self)
    def blackVol(self, *args): return _QuantLib.BlackVolTermStructure_blackVol(self, *args)
    def blackVariance(self, *args): return _QuantLib.BlackVolTermStructure_blackVariance(self, *args)
    def blackForwardVol(self, *args): return _QuantLib.BlackVolTermStructure_blackForwardVol(self, *args)
    def blackForwardVariance(self, *args): return _QuantLib.BlackVolTermStructure_blackForwardVariance(self, *args)
    def enableExtrapolation(self): return _QuantLib.BlackVolTermStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.BlackVolTermStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.BlackVolTermStructure_allowsExtrapolation(self)
BlackVolTermStructure_swigregister = _QuantLib.BlackVolTermStructure_swigregister
BlackVolTermStructure_swigregister(BlackVolTermStructure)

class BlackVolTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackVolTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.BlackVolTermStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.BlackVolTermStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.BlackVolTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructureHandle
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.BlackVolTermStructureHandle_referenceDate(self)
    def dayCounter(self): return _QuantLib.BlackVolTermStructureHandle_dayCounter(self)
    def calendar(self): return _QuantLib.BlackVolTermStructureHandle_calendar(self)
    def maxDate(self): return _QuantLib.BlackVolTermStructureHandle_maxDate(self)
    def maxTime(self): return _QuantLib.BlackVolTermStructureHandle_maxTime(self)
    def minStrike(self): return _QuantLib.BlackVolTermStructureHandle_minStrike(self)
    def maxStrike(self): return _QuantLib.BlackVolTermStructureHandle_maxStrike(self)
    def blackVol(self, *args): return _QuantLib.BlackVolTermStructureHandle_blackVol(self, *args)
    def blackVariance(self, *args): return _QuantLib.BlackVolTermStructureHandle_blackVariance(self, *args)
    def blackForwardVol(self, *args): return _QuantLib.BlackVolTermStructureHandle_blackForwardVol(self, *args)
    def blackForwardVariance(self, *args): return _QuantLib.BlackVolTermStructureHandle_blackForwardVariance(self, *args)
    def enableExtrapolation(self): return _QuantLib.BlackVolTermStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.BlackVolTermStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.BlackVolTermStructureHandle_allowsExtrapolation(self)
BlackVolTermStructureHandle_swigregister = _QuantLib.BlackVolTermStructureHandle_swigregister
BlackVolTermStructureHandle_swigregister(BlackVolTermStructureHandle)

class RelinkableBlackVolTermStructureHandle(BlackVolTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableBlackVolTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableBlackVolTermStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableBlackVolTermStructureHandle
    __del__ = lambda self : None;
RelinkableBlackVolTermStructureHandle_swigregister = _QuantLib.RelinkableBlackVolTermStructureHandle_swigregister
RelinkableBlackVolTermStructureHandle_swigregister(RelinkableBlackVolTermStructureHandle)

class LocalVolTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.LocalVolTermStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.LocalVolTermStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.LocalVolTermStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_LocalVolTermStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructure
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.LocalVolTermStructure_referenceDate(self)
    def dayCounter(self): return _QuantLib.LocalVolTermStructure_dayCounter(self)
    def calendar(self): return _QuantLib.LocalVolTermStructure_calendar(self)
    def maxDate(self): return _QuantLib.LocalVolTermStructure_maxDate(self)
    def maxTime(self): return _QuantLib.LocalVolTermStructure_maxTime(self)
    def minStrike(self): return _QuantLib.LocalVolTermStructure_minStrike(self)
    def maxStrike(self): return _QuantLib.LocalVolTermStructure_maxStrike(self)
    def localVol(self, *args): return _QuantLib.LocalVolTermStructure_localVol(self, *args)
    def enableExtrapolation(self): return _QuantLib.LocalVolTermStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.LocalVolTermStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.LocalVolTermStructure_allowsExtrapolation(self)
LocalVolTermStructure_swigregister = _QuantLib.LocalVolTermStructure_swigregister
LocalVolTermStructure_swigregister(LocalVolTermStructure)

class LocalVolTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LocalVolTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.LocalVolTermStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.LocalVolTermStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.LocalVolTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructureHandle
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.LocalVolTermStructureHandle_referenceDate(self)
    def dayCounter(self): return _QuantLib.LocalVolTermStructureHandle_dayCounter(self)
    def calendar(self): return _QuantLib.LocalVolTermStructureHandle_calendar(self)
    def maxDate(self): return _QuantLib.LocalVolTermStructureHandle_maxDate(self)
    def maxTime(self): return _QuantLib.LocalVolTermStructureHandle_maxTime(self)
    def minStrike(self): return _QuantLib.LocalVolTermStructureHandle_minStrike(self)
    def maxStrike(self): return _QuantLib.LocalVolTermStructureHandle_maxStrike(self)
    def localVol(self, *args): return _QuantLib.LocalVolTermStructureHandle_localVol(self, *args)
    def enableExtrapolation(self): return _QuantLib.LocalVolTermStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.LocalVolTermStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.LocalVolTermStructureHandle_allowsExtrapolation(self)
LocalVolTermStructureHandle_swigregister = _QuantLib.LocalVolTermStructureHandle_swigregister
LocalVolTermStructureHandle_swigregister(LocalVolTermStructureHandle)

class RelinkableLocalVolTermStructureHandle(LocalVolTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableLocalVolTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableLocalVolTermStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableLocalVolTermStructureHandle
    __del__ = lambda self : None;
RelinkableLocalVolTermStructureHandle_swigregister = _QuantLib.RelinkableLocalVolTermStructureHandle_swigregister
RelinkableLocalVolTermStructureHandle_swigregister(RelinkableLocalVolTermStructureHandle)

class OptionletVolatilityStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.OptionletVolatilityStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.OptionletVolatilityStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.OptionletVolatilityStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_OptionletVolatilityStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructure
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.OptionletVolatilityStructure_referenceDate(self)
    def dayCounter(self): return _QuantLib.OptionletVolatilityStructure_dayCounter(self)
    def calendar(self): return _QuantLib.OptionletVolatilityStructure_calendar(self)
    def maxDate(self): return _QuantLib.OptionletVolatilityStructure_maxDate(self)
    def maxTime(self): return _QuantLib.OptionletVolatilityStructure_maxTime(self)
    def minStrike(self): return _QuantLib.OptionletVolatilityStructure_minStrike(self)
    def maxStrike(self): return _QuantLib.OptionletVolatilityStructure_maxStrike(self)
    def volatility(self, *args): return _QuantLib.OptionletVolatilityStructure_volatility(self, *args)
    def blackVariance(self, *args): return _QuantLib.OptionletVolatilityStructure_blackVariance(self, *args)
    def enableExtrapolation(self): return _QuantLib.OptionletVolatilityStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.OptionletVolatilityStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.OptionletVolatilityStructure_allowsExtrapolation(self)
OptionletVolatilityStructure_swigregister = _QuantLib.OptionletVolatilityStructure_swigregister
OptionletVolatilityStructure_swigregister(OptionletVolatilityStructure)

class OptionletVolatilityStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_OptionletVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.OptionletVolatilityStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.OptionletVolatilityStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.OptionletVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructureHandle
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.OptionletVolatilityStructureHandle_referenceDate(self)
    def dayCounter(self): return _QuantLib.OptionletVolatilityStructureHandle_dayCounter(self)
    def calendar(self): return _QuantLib.OptionletVolatilityStructureHandle_calendar(self)
    def maxDate(self): return _QuantLib.OptionletVolatilityStructureHandle_maxDate(self)
    def maxTime(self): return _QuantLib.OptionletVolatilityStructureHandle_maxTime(self)
    def minStrike(self): return _QuantLib.OptionletVolatilityStructureHandle_minStrike(self)
    def maxStrike(self): return _QuantLib.OptionletVolatilityStructureHandle_maxStrike(self)
    def volatility(self, *args): return _QuantLib.OptionletVolatilityStructureHandle_volatility(self, *args)
    def blackVariance(self, *args): return _QuantLib.OptionletVolatilityStructureHandle_blackVariance(self, *args)
    def enableExtrapolation(self): return _QuantLib.OptionletVolatilityStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.OptionletVolatilityStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.OptionletVolatilityStructureHandle_allowsExtrapolation(self)
OptionletVolatilityStructureHandle_swigregister = _QuantLib.OptionletVolatilityStructureHandle_swigregister
OptionletVolatilityStructureHandle_swigregister(OptionletVolatilityStructureHandle)

class RelinkableOptionletVolatilityStructureHandle(OptionletVolatilityStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableOptionletVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableOptionletVolatilityStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableOptionletVolatilityStructureHandle
    __del__ = lambda self : None;
RelinkableOptionletVolatilityStructureHandle_swigregister = _QuantLib.RelinkableOptionletVolatilityStructureHandle_swigregister
RelinkableOptionletVolatilityStructureHandle_swigregister(RelinkableOptionletVolatilityStructureHandle)

class SwaptionVolatilityStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.SwaptionVolatilityStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.SwaptionVolatilityStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.SwaptionVolatilityStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_SwaptionVolatilityStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructure
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.SwaptionVolatilityStructure_referenceDate(self)
    def dayCounter(self): return _QuantLib.SwaptionVolatilityStructure_dayCounter(self)
    def calendar(self): return _QuantLib.SwaptionVolatilityStructure_calendar(self)
    def maxSwapTenor(self): return _QuantLib.SwaptionVolatilityStructure_maxSwapTenor(self)
    def maxSwapLength(self): return _QuantLib.SwaptionVolatilityStructure_maxSwapLength(self)
    def minStrike(self): return _QuantLib.SwaptionVolatilityStructure_minStrike(self)
    def maxStrike(self): return _QuantLib.SwaptionVolatilityStructure_maxStrike(self)
    def volatility(self, *args): return _QuantLib.SwaptionVolatilityStructure_volatility(self, *args)
    def blackVariance(self, *args): return _QuantLib.SwaptionVolatilityStructure_blackVariance(self, *args)
    def enableExtrapolation(self): return _QuantLib.SwaptionVolatilityStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.SwaptionVolatilityStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.SwaptionVolatilityStructure_allowsExtrapolation(self)
SwaptionVolatilityStructure_swigregister = _QuantLib.SwaptionVolatilityStructure_swigregister
SwaptionVolatilityStructure_swigregister(SwaptionVolatilityStructure)

class SwaptionVolatilityStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SwaptionVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.SwaptionVolatilityStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.SwaptionVolatilityStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.SwaptionVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructureHandle
    __del__ = lambda self : None;
    def referenceDate(self): return _QuantLib.SwaptionVolatilityStructureHandle_referenceDate(self)
    def dayCounter(self): return _QuantLib.SwaptionVolatilityStructureHandle_dayCounter(self)
    def calendar(self): return _QuantLib.SwaptionVolatilityStructureHandle_calendar(self)
    def maxSwapTenor(self): return _QuantLib.SwaptionVolatilityStructureHandle_maxSwapTenor(self)
    def maxSwapLength(self): return _QuantLib.SwaptionVolatilityStructureHandle_maxSwapLength(self)
    def minStrike(self): return _QuantLib.SwaptionVolatilityStructureHandle_minStrike(self)
    def maxStrike(self): return _QuantLib.SwaptionVolatilityStructureHandle_maxStrike(self)
    def volatility(self, *args): return _QuantLib.SwaptionVolatilityStructureHandle_volatility(self, *args)
    def blackVariance(self, *args): return _QuantLib.SwaptionVolatilityStructureHandle_blackVariance(self, *args)
    def enableExtrapolation(self): return _QuantLib.SwaptionVolatilityStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.SwaptionVolatilityStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.SwaptionVolatilityStructureHandle_allowsExtrapolation(self)
SwaptionVolatilityStructureHandle_swigregister = _QuantLib.SwaptionVolatilityStructureHandle_swigregister
SwaptionVolatilityStructureHandle_swigregister(SwaptionVolatilityStructureHandle)

class RelinkableSwaptionVolatilityStructureHandle(SwaptionVolatilityStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableSwaptionVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableSwaptionVolatilityStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableSwaptionVolatilityStructureHandle
    __del__ = lambda self : None;
RelinkableSwaptionVolatilityStructureHandle_swigregister = _QuantLib.RelinkableSwaptionVolatilityStructureHandle_swigregister
RelinkableSwaptionVolatilityStructureHandle_swigregister(RelinkableSwaptionVolatilityStructureHandle)

class BlackConstantVol(BlackVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackConstantVol(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackConstantVol
    __del__ = lambda self : None;
BlackConstantVol_swigregister = _QuantLib.BlackConstantVol_swigregister
BlackConstantVol_swigregister(BlackConstantVol)

class BlackVarianceCurve(BlackVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackVarianceCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackVarianceCurve
    __del__ = lambda self : None;
BlackVarianceCurve_swigregister = _QuantLib.BlackVarianceCurve_swigregister
BlackVarianceCurve_swigregister(BlackVarianceCurve)

class BlackVarianceSurface(BlackVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackVarianceSurface(*args)
        try: self.this.append(this)
        except: self.this = this
    ConstantExtrapolation = _QuantLib.BlackVarianceSurface_ConstantExtrapolation
    InterpolatorDefaultExtrapolation = _QuantLib.BlackVarianceSurface_InterpolatorDefaultExtrapolation
    __swig_destroy__ = _QuantLib.delete_BlackVarianceSurface
    __del__ = lambda self : None;
BlackVarianceSurface_swigregister = _QuantLib.BlackVarianceSurface_swigregister
BlackVarianceSurface_swigregister(BlackVarianceSurface)

class LocalConstantVol(LocalVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LocalConstantVol(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_LocalConstantVol
    __del__ = lambda self : None;
LocalConstantVol_swigregister = _QuantLib.LocalConstantVol_swigregister
LocalConstantVol_swigregister(LocalConstantVol)

class ConstantOptionletVolatility(OptionletVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ConstantOptionletVolatility(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ConstantOptionletVolatility
    __del__ = lambda self : None;
ConstantOptionletVolatility_swigregister = _QuantLib.ConstantOptionletVolatility_swigregister
ConstantOptionletVolatility_swigregister(ConstantOptionletVolatility)

class SwaptionVolatilityMatrix(SwaptionVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SwaptionVolatilityMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityMatrix
    __del__ = lambda self : None;
SwaptionVolatilityMatrix_swigregister = _QuantLib.SwaptionVolatilityMatrix_swigregister
SwaptionVolatilityMatrix_swigregister(SwaptionVolatilityMatrix)

class StochasticProcess(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.StochasticProcess___deref__(self)
    def __nonzero__(self): return _QuantLib.StochasticProcess___nonzero__(self)
    def asObservable(self): return _QuantLib.StochasticProcess_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_StochasticProcess()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_StochasticProcess
    __del__ = lambda self : None;
StochasticProcess_swigregister = _QuantLib.StochasticProcess_swigregister
StochasticProcess_swigregister(StochasticProcess)

class StochasticProcess1D(StochasticProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_StochasticProcess1D
    __del__ = lambda self : None;
StochasticProcess1D_swigregister = _QuantLib.StochasticProcess1D_swigregister
StochasticProcess1D_swigregister(StochasticProcess1D)

class GeneralizedBlackScholesProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GeneralizedBlackScholesProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    def stateVariable(self): return _QuantLib.GeneralizedBlackScholesProcess_stateVariable(self)
    def dividendYield(self): return _QuantLib.GeneralizedBlackScholesProcess_dividendYield(self)
    def riskFreeRate(self): return _QuantLib.GeneralizedBlackScholesProcess_riskFreeRate(self)
    def blackVolatility(self): return _QuantLib.GeneralizedBlackScholesProcess_blackVolatility(self)
    __swig_destroy__ = _QuantLib.delete_GeneralizedBlackScholesProcess
    __del__ = lambda self : None;
GeneralizedBlackScholesProcess_swigregister = _QuantLib.GeneralizedBlackScholesProcess_swigregister
GeneralizedBlackScholesProcess_swigregister(GeneralizedBlackScholesProcess)

class BlackScholesProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackScholesProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackScholesProcess
    __del__ = lambda self : None;
BlackScholesProcess_swigregister = _QuantLib.BlackScholesProcess_swigregister
BlackScholesProcess_swigregister(BlackScholesProcess)

class BlackScholesMertonProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackScholesMertonProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackScholesMertonProcess
    __del__ = lambda self : None;
BlackScholesMertonProcess_swigregister = _QuantLib.BlackScholesMertonProcess_swigregister
BlackScholesMertonProcess_swigregister(BlackScholesMertonProcess)

class BlackProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackProcess
    __del__ = lambda self : None;
BlackProcess_swigregister = _QuantLib.BlackProcess_swigregister
BlackProcess_swigregister(BlackProcess)

class GarmanKohlagenProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GarmanKohlagenProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_GarmanKohlagenProcess
    __del__ = lambda self : None;
GarmanKohlagenProcess_swigregister = _QuantLib.GarmanKohlagenProcess_swigregister
GarmanKohlagenProcess_swigregister(GarmanKohlagenProcess)

class Merton76Process(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Merton76Process(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Merton76Process
    __del__ = lambda self : None;
Merton76Process_swigregister = _QuantLib.Merton76Process_swigregister
Merton76Process_swigregister(Merton76Process)

class StochasticProcessArray(StochasticProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_StochasticProcessArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_StochasticProcessArray
    __del__ = lambda self : None;
StochasticProcessArray_swigregister = _QuantLib.StochasticProcessArray_swigregister
StochasticProcessArray_swigregister(StochasticProcessArray)

class GeometricBrownianMotionProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GeometricBrownianMotionProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_GeometricBrownianMotionProcess
    __del__ = lambda self : None;
GeometricBrownianMotionProcess_swigregister = _QuantLib.GeometricBrownianMotionProcess_swigregister
GeometricBrownianMotionProcess_swigregister(GeometricBrownianMotionProcess)

class StochasticProcessVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.StochasticProcessVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.StochasticProcessVector___nonzero__(self)
    def __bool__(self): return _QuantLib.StochasticProcessVector___bool__(self)
    def __len__(self): return _QuantLib.StochasticProcessVector___len__(self)
    def pop(self): return _QuantLib.StochasticProcessVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.StochasticProcessVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.StochasticProcessVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.StochasticProcessVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.StochasticProcessVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.StochasticProcessVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.StochasticProcessVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.StochasticProcessVector_append(self, *args)
    def empty(self): return _QuantLib.StochasticProcessVector_empty(self)
    def size(self): return _QuantLib.StochasticProcessVector_size(self)
    def clear(self): return _QuantLib.StochasticProcessVector_clear(self)
    def swap(self, *args): return _QuantLib.StochasticProcessVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.StochasticProcessVector_get_allocator(self)
    def begin(self): return _QuantLib.StochasticProcessVector_begin(self)
    def end(self): return _QuantLib.StochasticProcessVector_end(self)
    def rbegin(self): return _QuantLib.StochasticProcessVector_rbegin(self)
    def rend(self): return _QuantLib.StochasticProcessVector_rend(self)
    def pop_back(self): return _QuantLib.StochasticProcessVector_pop_back(self)
    def erase(self, *args): return _QuantLib.StochasticProcessVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_StochasticProcessVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.StochasticProcessVector_push_back(self, *args)
    def front(self): return _QuantLib.StochasticProcessVector_front(self)
    def back(self): return _QuantLib.StochasticProcessVector_back(self)
    def assign(self, *args): return _QuantLib.StochasticProcessVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.StochasticProcessVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.StochasticProcessVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.StochasticProcessVector_reserve(self, *args)
    def capacity(self): return _QuantLib.StochasticProcessVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StochasticProcessVector
    __del__ = lambda self : None;
StochasticProcessVector_swigregister = _QuantLib.StochasticProcessVector_swigregister
StochasticProcessVector_swigregister(StochasticProcessVector)

class PricingEngine(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.PricingEngine___deref__(self)
    def __nonzero__(self): return _QuantLib.PricingEngine___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_PricingEngine()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PricingEngine
    __del__ = lambda self : None;
PricingEngine_swigregister = _QuantLib.PricingEngine_swigregister
PricingEngine_swigregister(PricingEngine)

class Instrument(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Instrument___deref__(self)
    def __nonzero__(self): return _QuantLib.Instrument___nonzero__(self)
    def asObservable(self): return _QuantLib.Instrument_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_Instrument()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Instrument
    __del__ = lambda self : None;
    def NPV(self): return _QuantLib.Instrument_NPV(self)
    def errorEstimate(self): return _QuantLib.Instrument_errorEstimate(self)
    def isExpired(self): return _QuantLib.Instrument_isExpired(self)
    def setPricingEngine(self, *args): return _QuantLib.Instrument_setPricingEngine(self, *args)
    def recalculate(self): return _QuantLib.Instrument_recalculate(self)
    def freeze(self): return _QuantLib.Instrument_freeze(self)
    def unfreeze(self): return _QuantLib.Instrument_unfreeze(self)
Instrument_swigregister = _QuantLib.Instrument_swigregister
Instrument_swigregister(Instrument)

class Stock(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Stock(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Stock
    __del__ = lambda self : None;
Stock_swigregister = _QuantLib.Stock_swigregister
Stock_swigregister(Stock)

class CompositeInstrument(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_CompositeInstrument()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args): return _QuantLib.CompositeInstrument_add(self, *args)
    def subtract(self, *args): return _QuantLib.CompositeInstrument_subtract(self, *args)
    __swig_destroy__ = _QuantLib.delete_CompositeInstrument
    __del__ = lambda self : None;
CompositeInstrument_swigregister = _QuantLib.CompositeInstrument_swigregister
CompositeInstrument_swigregister(CompositeInstrument)

class Option(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Put = _QuantLib.Option_Put
    Call = _QuantLib.Option_Call
    __swig_destroy__ = _QuantLib.delete_Option
    __del__ = lambda self : None;
Option_swigregister = _QuantLib.Option_swigregister
Option_swigregister(Option)

class Barrier(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DownIn = _QuantLib.Barrier_DownIn
    UpIn = _QuantLib.Barrier_UpIn
    DownOut = _QuantLib.Barrier_DownOut
    UpOut = _QuantLib.Barrier_UpOut
    def __init__(self): 
        this = _QuantLib.new_Barrier()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Barrier
    __del__ = lambda self : None;
Barrier_swigregister = _QuantLib.Barrier_swigregister
Barrier_swigregister(Barrier)

class Payoff(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Payoff___deref__(self)
    def __nonzero__(self): return _QuantLib.Payoff___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_Payoff()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Payoff
    __del__ = lambda self : None;
    def __call__(self, *args): return _QuantLib.Payoff___call__(self, *args)
Payoff_swigregister = _QuantLib.Payoff_swigregister
Payoff_swigregister(Payoff)

class VanillaOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_VanillaOption(*args)
        try: self.this.append(this)
        except: self.this = this
    def priceCurve(self): return _QuantLib.VanillaOption_priceCurve(self)
    def impliedVolatility(self, *args): return _QuantLib.VanillaOption_impliedVolatility(self, *args)
    def delta(self): return _QuantLib.VanillaOption_delta(self)
    def gamma(self): return _QuantLib.VanillaOption_gamma(self)
    def theta(self): return _QuantLib.VanillaOption_theta(self)
    def thetaPerDay(self): return _QuantLib.VanillaOption_thetaPerDay(self)
    def vega(self): return _QuantLib.VanillaOption_vega(self)
    def rho(self): return _QuantLib.VanillaOption_rho(self)
    def dividendRho(self): return _QuantLib.VanillaOption_dividendRho(self)
    def strikeSensitivity(self): return _QuantLib.VanillaOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_VanillaOption
    __del__ = lambda self : None;
VanillaOption_swigregister = _QuantLib.VanillaOption_swigregister
VanillaOption_swigregister(VanillaOption)

class EuropeanOption(VanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EuropeanOption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EuropeanOption
    __del__ = lambda self : None;
EuropeanOption_swigregister = _QuantLib.EuropeanOption_swigregister
EuropeanOption_swigregister(EuropeanOption)

class ForwardVanillaOption(VanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ForwardVanillaOption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardVanillaOption
    __del__ = lambda self : None;
ForwardVanillaOption_swigregister = _QuantLib.ForwardVanillaOption_swigregister
ForwardVanillaOption_swigregister(ForwardVanillaOption)

class QuantoVanillaOption(VanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_QuantoVanillaOption(*args)
        try: self.this.append(this)
        except: self.this = this
    def qvega(self): return _QuantLib.QuantoVanillaOption_qvega(self)
    def qrho(self): return _QuantLib.QuantoVanillaOption_qrho(self)
    def qlambda(self): return _QuantLib.QuantoVanillaOption_qlambda(self)
    __swig_destroy__ = _QuantLib.delete_QuantoVanillaOption
    __del__ = lambda self : None;
QuantoVanillaOption_swigregister = _QuantLib.QuantoVanillaOption_swigregister
QuantoVanillaOption_swigregister(QuantoVanillaOption)

class QuantoForwardVanillaOption(QuantoVanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_QuantoForwardVanillaOption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_QuantoForwardVanillaOption
    __del__ = lambda self : None;
QuantoForwardVanillaOption_swigregister = _QuantLib.QuantoForwardVanillaOption_swigregister
QuantoForwardVanillaOption_swigregister(QuantoForwardVanillaOption)

class MultiAssetOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def delta(self): return _QuantLib.MultiAssetOption_delta(self)
    def gamma(self): return _QuantLib.MultiAssetOption_gamma(self)
    def theta(self): return _QuantLib.MultiAssetOption_theta(self)
    def vega(self): return _QuantLib.MultiAssetOption_vega(self)
    def rho(self): return _QuantLib.MultiAssetOption_rho(self)
    def dividendRho(self): return _QuantLib.MultiAssetOption_dividendRho(self)
    def __init__(self): 
        this = _QuantLib.new_MultiAssetOption()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MultiAssetOption
    __del__ = lambda self : None;
MultiAssetOption_swigregister = _QuantLib.MultiAssetOption_swigregister
MultiAssetOption_swigregister(MultiAssetOption)

class AnalyticEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticEuropeanEngine
    __del__ = lambda self : None;
AnalyticEuropeanEngine_swigregister = _QuantLib.AnalyticEuropeanEngine_swigregister
AnalyticEuropeanEngine_swigregister(AnalyticEuropeanEngine)

class IntegralEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_IntegralEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_IntegralEngine
    __del__ = lambda self : None;
IntegralEngine_swigregister = _QuantLib.IntegralEngine_swigregister
IntegralEngine_swigregister(IntegralEngine)

class FDBermudanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FDBermudanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FDBermudanEngine
    __del__ = lambda self : None;
FDBermudanEngine_swigregister = _QuantLib.FDBermudanEngine_swigregister
FDBermudanEngine_swigregister(FDBermudanEngine)

class FDEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FDEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FDEuropeanEngine
    __del__ = lambda self : None;
FDEuropeanEngine_swigregister = _QuantLib.FDEuropeanEngine_swigregister
FDEuropeanEngine_swigregister(FDEuropeanEngine)

class BinomialVanillaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BinomialVanillaEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialVanillaEngine
    __del__ = lambda self : None;
BinomialVanillaEngine_swigregister = _QuantLib.BinomialVanillaEngine_swigregister
BinomialVanillaEngine_swigregister(BinomialVanillaEngine)

class MCEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCEuropeanEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCEuropeanEngine
    __del__ = lambda self : None;
MCEuropeanEngine_swigregister = _QuantLib.MCEuropeanEngine_swigregister
MCEuropeanEngine_swigregister(MCEuropeanEngine)

class FDAmericanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FDAmericanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FDAmericanEngine
    __del__ = lambda self : None;
FDAmericanEngine_swigregister = _QuantLib.FDAmericanEngine_swigregister
FDAmericanEngine_swigregister(FDAmericanEngine)

class FDShoutEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FDShoutEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FDShoutEngine
    __del__ = lambda self : None;
FDShoutEngine_swigregister = _QuantLib.FDShoutEngine_swigregister
FDShoutEngine_swigregister(FDShoutEngine)

class BaroneAdesiWhaleyEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BaroneAdesiWhaleyEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BaroneAdesiWhaleyEngine
    __del__ = lambda self : None;
BaroneAdesiWhaleyEngine_swigregister = _QuantLib.BaroneAdesiWhaleyEngine_swigregister
BaroneAdesiWhaleyEngine_swigregister(BaroneAdesiWhaleyEngine)

class BjerksundStenslandEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BjerksundStenslandEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BjerksundStenslandEngine
    __del__ = lambda self : None;
BjerksundStenslandEngine_swigregister = _QuantLib.BjerksundStenslandEngine_swigregister
BjerksundStenslandEngine_swigregister(BjerksundStenslandEngine)

class AnalyticDigitalAmericanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticDigitalAmericanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanEngine
    __del__ = lambda self : None;
AnalyticDigitalAmericanEngine_swigregister = _QuantLib.AnalyticDigitalAmericanEngine_swigregister
AnalyticDigitalAmericanEngine_swigregister(AnalyticDigitalAmericanEngine)

class DividendVanillaOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DividendVanillaOption(*args)
        try: self.this.append(this)
        except: self.this = this
    def priceCurve(self): return _QuantLib.DividendVanillaOption_priceCurve(self)
    def impliedVolatility(self, *args): return _QuantLib.DividendVanillaOption_impliedVolatility(self, *args)
    def delta(self): return _QuantLib.DividendVanillaOption_delta(self)
    def gamma(self): return _QuantLib.DividendVanillaOption_gamma(self)
    def theta(self): return _QuantLib.DividendVanillaOption_theta(self)
    def thetaPerDay(self): return _QuantLib.DividendVanillaOption_thetaPerDay(self)
    def vega(self): return _QuantLib.DividendVanillaOption_vega(self)
    def rho(self): return _QuantLib.DividendVanillaOption_rho(self)
    def dividendRho(self): return _QuantLib.DividendVanillaOption_dividendRho(self)
    def strikeSensitivity(self): return _QuantLib.DividendVanillaOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_DividendVanillaOption
    __del__ = lambda self : None;
DividendVanillaOption_swigregister = _QuantLib.DividendVanillaOption_swigregister
DividendVanillaOption_swigregister(DividendVanillaOption)

class AnalyticDividendEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticDividendEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDividendEuropeanEngine
    __del__ = lambda self : None;
AnalyticDividendEuropeanEngine_swigregister = _QuantLib.AnalyticDividendEuropeanEngine_swigregister
AnalyticDividendEuropeanEngine_swigregister(AnalyticDividendEuropeanEngine)

class FDDividendEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FDDividendEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FDDividendEuropeanEngine
    __del__ = lambda self : None;
FDDividendEuropeanEngine_swigregister = _QuantLib.FDDividendEuropeanEngine_swigregister
FDDividendEuropeanEngine_swigregister(FDDividendEuropeanEngine)

class FDDividendAmericanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FDDividendAmericanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FDDividendAmericanEngine
    __del__ = lambda self : None;
FDDividendAmericanEngine_swigregister = _QuantLib.FDDividendAmericanEngine_swigregister
FDDividendAmericanEngine_swigregister(FDDividendAmericanEngine)

class BarrierOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BarrierOption(*args)
        try: self.this.append(this)
        except: self.this = this
    def priceCurve(self): return _QuantLib.BarrierOption_priceCurve(self)
    def impliedVolatility(self, *args): return _QuantLib.BarrierOption_impliedVolatility(self, *args)
    def delta(self): return _QuantLib.BarrierOption_delta(self)
    def gamma(self): return _QuantLib.BarrierOption_gamma(self)
    def theta(self): return _QuantLib.BarrierOption_theta(self)
    def thetaPerDay(self): return _QuantLib.BarrierOption_thetaPerDay(self)
    def vega(self): return _QuantLib.BarrierOption_vega(self)
    def rho(self): return _QuantLib.BarrierOption_rho(self)
    def dividendRho(self): return _QuantLib.BarrierOption_dividendRho(self)
    def strikeSensitivity(self): return _QuantLib.BarrierOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_BarrierOption
    __del__ = lambda self : None;
BarrierOption_swigregister = _QuantLib.BarrierOption_swigregister
BarrierOption_swigregister(BarrierOption)

class AnalyticBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticBarrierEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticBarrierEngine
    __del__ = lambda self : None;
AnalyticBarrierEngine_swigregister = _QuantLib.AnalyticBarrierEngine_swigregister
AnalyticBarrierEngine_swigregister(AnalyticBarrierEngine)

class MCBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCBarrierEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCBarrierEngine
    __del__ = lambda self : None;
MCBarrierEngine_swigregister = _QuantLib.MCBarrierEngine_swigregister
MCBarrierEngine_swigregister(MCBarrierEngine)

class ForwardEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ForwardEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardEuropeanEngine
    __del__ = lambda self : None;
ForwardEuropeanEngine_swigregister = _QuantLib.ForwardEuropeanEngine_swigregister
ForwardEuropeanEngine_swigregister(ForwardEuropeanEngine)

class QuantoEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_QuantoEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_QuantoEuropeanEngine
    __del__ = lambda self : None;
QuantoEuropeanEngine_swigregister = _QuantLib.QuantoEuropeanEngine_swigregister
QuantoEuropeanEngine_swigregister(QuantoEuropeanEngine)

class QuantoForwardEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_QuantoForwardEuropeanEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_QuantoForwardEuropeanEngine
    __del__ = lambda self : None;
QuantoForwardEuropeanEngine_swigregister = _QuantLib.QuantoForwardEuropeanEngine_swigregister
QuantoForwardEuropeanEngine_swigregister(QuantoForwardEuropeanEngine)

class BlackCalculator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackCalculator(*args)
        try: self.this.append(this)
        except: self.this = this
    def value(self): return _QuantLib.BlackCalculator_value(self)
    def deltaForward(self): return _QuantLib.BlackCalculator_deltaForward(self)
    def delta(self, *args): return _QuantLib.BlackCalculator_delta(self, *args)
    def elasticityForward(self): return _QuantLib.BlackCalculator_elasticityForward(self)
    def elasticity(self, *args): return _QuantLib.BlackCalculator_elasticity(self, *args)
    def gammaForward(self): return _QuantLib.BlackCalculator_gammaForward(self)
    def gamma(self, *args): return _QuantLib.BlackCalculator_gamma(self, *args)
    def theta(self, *args): return _QuantLib.BlackCalculator_theta(self, *args)
    def thetaPerDay(self, *args): return _QuantLib.BlackCalculator_thetaPerDay(self, *args)
    def vega(self, *args): return _QuantLib.BlackCalculator_vega(self, *args)
    def rho(self, *args): return _QuantLib.BlackCalculator_rho(self, *args)
    def dividendRho(self, *args): return _QuantLib.BlackCalculator_dividendRho(self, *args)
    def itmCashProbability(self): return _QuantLib.BlackCalculator_itmCashProbability(self)
    def itmAssetProbability(self): return _QuantLib.BlackCalculator_itmAssetProbability(self)
    def strikeSensitivity(self): return _QuantLib.BlackCalculator_strikeSensitivity(self)
    def alpha(self): return _QuantLib.BlackCalculator_alpha(self)
    def beta(self): return _QuantLib.BlackCalculator_beta(self)
    __swig_destroy__ = _QuantLib.delete_BlackCalculator
    __del__ = lambda self : None;
BlackCalculator_swigregister = _QuantLib.BlackCalculator_swigregister
BlackCalculator_swigregister(BlackCalculator)

class Average(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Arithmetic = _QuantLib.Average_Arithmetic
    Geometric = _QuantLib.Average_Geometric
    def __init__(self): 
        this = _QuantLib.new_Average()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Average
    __del__ = lambda self : None;
Average_swigregister = _QuantLib.Average_swigregister
Average_swigregister(Average)

class ContinuousAveragingAsianOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ContinuousAveragingAsianOption(*args)
        try: self.this.append(this)
        except: self.this = this
    def delta(self): return _QuantLib.ContinuousAveragingAsianOption_delta(self)
    def gamma(self): return _QuantLib.ContinuousAveragingAsianOption_gamma(self)
    def theta(self): return _QuantLib.ContinuousAveragingAsianOption_theta(self)
    def thetaPerDay(self): return _QuantLib.ContinuousAveragingAsianOption_thetaPerDay(self)
    def vega(self): return _QuantLib.ContinuousAveragingAsianOption_vega(self)
    def rho(self): return _QuantLib.ContinuousAveragingAsianOption_rho(self)
    def dividendRho(self): return _QuantLib.ContinuousAveragingAsianOption_dividendRho(self)
    def strikeSensitivity(self): return _QuantLib.ContinuousAveragingAsianOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_ContinuousAveragingAsianOption
    __del__ = lambda self : None;
ContinuousAveragingAsianOption_swigregister = _QuantLib.ContinuousAveragingAsianOption_swigregister
ContinuousAveragingAsianOption_swigregister(ContinuousAveragingAsianOption)

class DiscreteAveragingAsianOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DiscreteAveragingAsianOption(*args)
        try: self.this.append(this)
        except: self.this = this
    def delta(self): return _QuantLib.DiscreteAveragingAsianOption_delta(self)
    def gamma(self): return _QuantLib.DiscreteAveragingAsianOption_gamma(self)
    def theta(self): return _QuantLib.DiscreteAveragingAsianOption_theta(self)
    def thetaPerDay(self): return _QuantLib.DiscreteAveragingAsianOption_thetaPerDay(self)
    def vega(self): return _QuantLib.DiscreteAveragingAsianOption_vega(self)
    def rho(self): return _QuantLib.DiscreteAveragingAsianOption_rho(self)
    def dividendRho(self): return _QuantLib.DiscreteAveragingAsianOption_dividendRho(self)
    def strikeSensitivity(self): return _QuantLib.DiscreteAveragingAsianOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_DiscreteAveragingAsianOption
    __del__ = lambda self : None;
DiscreteAveragingAsianOption_swigregister = _QuantLib.DiscreteAveragingAsianOption_swigregister
DiscreteAveragingAsianOption_swigregister(DiscreteAveragingAsianOption)

class AnalyticContinuousGeometricAveragePriceAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticContinuousGeometricAveragePriceAsianEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousGeometricAveragePriceAsianEngine
    __del__ = lambda self : None;
AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister = _QuantLib.AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister
AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister(AnalyticContinuousGeometricAveragePriceAsianEngine)

class AnalyticDiscreteGeometricAveragePriceAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticDiscreteGeometricAveragePriceAsianEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAveragePriceAsianEngine
    __del__ = lambda self : None;
AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister = _QuantLib.AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister
AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister(AnalyticDiscreteGeometricAveragePriceAsianEngine)

class AnalyticDiscreteGeometricAverageStrikeAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine
    __del__ = lambda self : None;
AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister = _QuantLib.AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister
AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister(AnalyticDiscreteGeometricAverageStrikeAsianEngine)

class MCDiscreteArithmeticAPEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCDiscreteArithmeticAPEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCDiscreteArithmeticAPEngine
    __del__ = lambda self : None;
MCDiscreteArithmeticAPEngine_swigregister = _QuantLib.MCDiscreteArithmeticAPEngine_swigregister
MCDiscreteArithmeticAPEngine_swigregister(MCDiscreteArithmeticAPEngine)

class MCDiscreteArithmeticASEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCDiscreteArithmeticASEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCDiscreteArithmeticASEngine
    __del__ = lambda self : None;
MCDiscreteArithmeticASEngine_swigregister = _QuantLib.MCDiscreteArithmeticASEngine_swigregister
MCDiscreteArithmeticASEngine_swigregister(MCDiscreteArithmeticASEngine)

class MCDiscreteGeometricAPEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCDiscreteGeometricAPEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCDiscreteGeometricAPEngine
    __del__ = lambda self : None;
MCDiscreteGeometricAPEngine_swigregister = _QuantLib.MCDiscreteGeometricAPEngine_swigregister
MCDiscreteGeometricAPEngine_swigregister(MCDiscreteGeometricAPEngine)

class PlainVanillaPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_PlainVanillaPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PlainVanillaPayoff
    __del__ = lambda self : None;
PlainVanillaPayoff_swigregister = _QuantLib.PlainVanillaPayoff_swigregister
PlainVanillaPayoff_swigregister(PlainVanillaPayoff)

class PercentageStrikePayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_PercentageStrikePayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PercentageStrikePayoff
    __del__ = lambda self : None;
PercentageStrikePayoff_swigregister = _QuantLib.PercentageStrikePayoff_swigregister
PercentageStrikePayoff_swigregister(PercentageStrikePayoff)

class CashOrNothingPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CashOrNothingPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CashOrNothingPayoff
    __del__ = lambda self : None;
CashOrNothingPayoff_swigregister = _QuantLib.CashOrNothingPayoff_swigregister
CashOrNothingPayoff_swigregister(CashOrNothingPayoff)

class AssetOrNothingPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AssetOrNothingPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AssetOrNothingPayoff
    __del__ = lambda self : None;
AssetOrNothingPayoff_swigregister = _QuantLib.AssetOrNothingPayoff_swigregister
AssetOrNothingPayoff_swigregister(AssetOrNothingPayoff)

class SuperSharePayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SuperSharePayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SuperSharePayoff
    __del__ = lambda self : None;
SuperSharePayoff_swigregister = _QuantLib.SuperSharePayoff_swigregister
SuperSharePayoff_swigregister(SuperSharePayoff)

class GapPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GapPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_GapPayoff
    __del__ = lambda self : None;
GapPayoff_swigregister = _QuantLib.GapPayoff_swigregister
GapPayoff_swigregister(GapPayoff)

class BasketPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BasketPayoff()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BasketPayoff
    __del__ = lambda self : None;
BasketPayoff_swigregister = _QuantLib.BasketPayoff_swigregister
BasketPayoff_swigregister(BasketPayoff)

class MinBasketPayoff(BasketPayoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MinBasketPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MinBasketPayoff
    __del__ = lambda self : None;
MinBasketPayoff_swigregister = _QuantLib.MinBasketPayoff_swigregister
MinBasketPayoff_swigregister(MinBasketPayoff)

class MaxBasketPayoff(BasketPayoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MaxBasketPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MaxBasketPayoff
    __del__ = lambda self : None;
MaxBasketPayoff_swigregister = _QuantLib.MaxBasketPayoff_swigregister
MaxBasketPayoff_swigregister(MaxBasketPayoff)

class AverageBasketPayoff(BasketPayoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AverageBasketPayoff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AverageBasketPayoff
    __del__ = lambda self : None;
AverageBasketPayoff_swigregister = _QuantLib.AverageBasketPayoff_swigregister
AverageBasketPayoff_swigregister(AverageBasketPayoff)

class BasketOption(MultiAssetOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BasketOption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BasketOption
    __del__ = lambda self : None;
BasketOption_swigregister = _QuantLib.BasketOption_swigregister
BasketOption_swigregister(BasketOption)

class MCEuropeanBasketEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCEuropeanBasketEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCEuropeanBasketEngine
    __del__ = lambda self : None;
MCEuropeanBasketEngine_swigregister = _QuantLib.MCEuropeanBasketEngine_swigregister
MCEuropeanBasketEngine_swigregister(MCEuropeanBasketEngine)

class MCAmericanBasketEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCAmericanBasketEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCAmericanBasketEngine
    __del__ = lambda self : None;
MCAmericanBasketEngine_swigregister = _QuantLib.MCAmericanBasketEngine_swigregister
MCAmericanBasketEngine_swigregister(MCAmericanBasketEngine)

class StulzEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_StulzEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_StulzEngine
    __del__ = lambda self : None;
StulzEngine_swigregister = _QuantLib.StulzEngine_swigregister
StulzEngine_swigregister(StulzEngine)

class EverestOption(MultiAssetOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EverestOption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EverestOption
    __del__ = lambda self : None;
EverestOption_swigregister = _QuantLib.EverestOption_swigregister
EverestOption_swigregister(EverestOption)

class MCEverestEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCEverestEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCEverestEngine
    __del__ = lambda self : None;
MCEverestEngine_swigregister = _QuantLib.MCEverestEngine_swigregister
MCEverestEngine_swigregister(MCEverestEngine)

class HimalayaOption(MultiAssetOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_HimalayaOption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_HimalayaOption
    __del__ = lambda self : None;
HimalayaOption_swigregister = _QuantLib.HimalayaOption_swigregister
HimalayaOption_swigregister(HimalayaOption)

class MCHimalayaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_MCHimalayaEngine(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MCHimalayaEngine
    __del__ = lambda self : None;
MCHimalayaEngine_swigregister = _QuantLib.MCHimalayaEngine_swigregister
MCHimalayaEngine_swigregister(MCHimalayaEngine)

class RealTimeSeries(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RealTimeSeries(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.RealTimeSeries_dates(self)
    def values(self): return _QuantLib.RealTimeSeries_values(self)
    def __len__(self): return _QuantLib.RealTimeSeries___len__(self)
    def __getitem__(self, *args): return _QuantLib.RealTimeSeries___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.RealTimeSeries___setitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_RealTimeSeries
    __del__ = lambda self : None;
RealTimeSeries_swigregister = _QuantLib.RealTimeSeries_swigregister
RealTimeSeries_swigregister(RealTimeSeries)

class IntervalPriceTimeSeries(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_IntervalPriceTimeSeries(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.IntervalPriceTimeSeries_dates(self)
    def values(self): return _QuantLib.IntervalPriceTimeSeries_values(self)
    def __len__(self): return _QuantLib.IntervalPriceTimeSeries___len__(self)
    def __getitem__(self, *args): return _QuantLib.IntervalPriceTimeSeries___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.IntervalPriceTimeSeries___setitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceTimeSeries
    __del__ = lambda self : None;
IntervalPriceTimeSeries_swigregister = _QuantLib.IntervalPriceTimeSeries_swigregister
IntervalPriceTimeSeries_swigregister(IntervalPriceTimeSeries)

class IntervalPriceVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.IntervalPriceVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.IntervalPriceVector___nonzero__(self)
    def __bool__(self): return _QuantLib.IntervalPriceVector___bool__(self)
    def __len__(self): return _QuantLib.IntervalPriceVector___len__(self)
    def pop(self): return _QuantLib.IntervalPriceVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.IntervalPriceVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.IntervalPriceVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.IntervalPriceVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.IntervalPriceVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.IntervalPriceVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.IntervalPriceVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.IntervalPriceVector_append(self, *args)
    def empty(self): return _QuantLib.IntervalPriceVector_empty(self)
    def size(self): return _QuantLib.IntervalPriceVector_size(self)
    def clear(self): return _QuantLib.IntervalPriceVector_clear(self)
    def swap(self, *args): return _QuantLib.IntervalPriceVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.IntervalPriceVector_get_allocator(self)
    def begin(self): return _QuantLib.IntervalPriceVector_begin(self)
    def end(self): return _QuantLib.IntervalPriceVector_end(self)
    def rbegin(self): return _QuantLib.IntervalPriceVector_rbegin(self)
    def rend(self): return _QuantLib.IntervalPriceVector_rend(self)
    def pop_back(self): return _QuantLib.IntervalPriceVector_pop_back(self)
    def erase(self, *args): return _QuantLib.IntervalPriceVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_IntervalPriceVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.IntervalPriceVector_push_back(self, *args)
    def front(self): return _QuantLib.IntervalPriceVector_front(self)
    def back(self): return _QuantLib.IntervalPriceVector_back(self)
    def assign(self, *args): return _QuantLib.IntervalPriceVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.IntervalPriceVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.IntervalPriceVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.IntervalPriceVector_reserve(self, *args)
    def capacity(self): return _QuantLib.IntervalPriceVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceVector
    __del__ = lambda self : None;
IntervalPriceVector_swigregister = _QuantLib.IntervalPriceVector_swigregister
IntervalPriceVector_swigregister(IntervalPriceVector)

class IntervalPrice(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Open = _QuantLib.IntervalPrice_Open
    Close = _QuantLib.IntervalPrice_Close
    High = _QuantLib.IntervalPrice_High
    Low = _QuantLib.IntervalPrice_Low
    def __init__(self, *args): 
        this = _QuantLib.new_IntervalPrice(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args): return _QuantLib.IntervalPrice_setValue(self, *args)
    def setValues(self, *args): return _QuantLib.IntervalPrice_setValues(self, *args)
    def value(self, *args): return _QuantLib.IntervalPrice_value(self, *args)
    def open(self): return _QuantLib.IntervalPrice_open(self)
    def close(self): return _QuantLib.IntervalPrice_close(self)
    def high(self): return _QuantLib.IntervalPrice_high(self)
    def low(self): return _QuantLib.IntervalPrice_low(self)
    makeSeries = staticmethod(_QuantLib.IntervalPrice_makeSeries)
    extractValues = staticmethod(_QuantLib.IntervalPrice_extractValues)
    extractComponent = staticmethod(_QuantLib.IntervalPrice_extractComponent)
    __swig_destroy__ = _QuantLib.delete_IntervalPrice
    __del__ = lambda self : None;
IntervalPrice_swigregister = _QuantLib.IntervalPrice_swigregister
IntervalPrice_swigregister(IntervalPrice)

def IntervalPrice_makeSeries(*args):
  return _QuantLib.IntervalPrice_makeSeries(*args)
IntervalPrice_makeSeries = _QuantLib.IntervalPrice_makeSeries

def IntervalPrice_extractValues(*args):
  return _QuantLib.IntervalPrice_extractValues(*args)
IntervalPrice_extractValues = _QuantLib.IntervalPrice_extractValues

def IntervalPrice_extractComponent(*args):
  return _QuantLib.IntervalPrice_extractComponent(*args)
IntervalPrice_extractComponent = _QuantLib.IntervalPrice_extractComponent

class IndexManager(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    instance = staticmethod(_QuantLib.IndexManager_instance)
    def setHistory(self, *args): return _QuantLib.IndexManager_setHistory(self, *args)
    def getHistory(self, *args): return _QuantLib.IndexManager_getHistory(self, *args)
    def hasHistory(self, *args): return _QuantLib.IndexManager_hasHistory(self, *args)
    def histories(self): return _QuantLib.IndexManager_histories(self)
    def clearHistory(self, *args): return _QuantLib.IndexManager_clearHistory(self, *args)
    def clearHistories(self): return _QuantLib.IndexManager_clearHistories(self)
    __swig_destroy__ = _QuantLib.delete_IndexManager
    __del__ = lambda self : None;
IndexManager_swigregister = _QuantLib.IndexManager_swigregister
IndexManager_swigregister(IndexManager)

def IndexManager_instance():
  return _QuantLib.IndexManager_instance()
IndexManager_instance = _QuantLib.IndexManager_instance

class Index(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Index___deref__(self)
    def __nonzero__(self): return _QuantLib.Index___nonzero__(self)
    def addFixings(self, *args): return _QuantLib.Index_addFixings(self, *args)
    def __str__(self): return _QuantLib.Index___str__(self)
    def asObservable(self): return _QuantLib.Index_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_Index()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Index
    __del__ = lambda self : None;
    def name(self): return _QuantLib.Index_name(self)
    def fixingCalendar(self): return _QuantLib.Index_fixingCalendar(self)
    def isValidFixingDate(self, *args): return _QuantLib.Index_isValidFixingDate(self, *args)
    def fixing(self, *args): return _QuantLib.Index_fixing(self, *args)
    def addFixing(self, *args): return _QuantLib.Index_addFixing(self, *args)
Index_swigregister = _QuantLib.Index_swigregister
Index_swigregister(Index)

class InterestRateIndex(Index):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def familyName(self): return _QuantLib.InterestRateIndex_familyName(self)
    def tenor(self): return _QuantLib.InterestRateIndex_tenor(self)
    def fixingDays(self): return _QuantLib.InterestRateIndex_fixingDays(self)
    def fixingDate(self, *args): return _QuantLib.InterestRateIndex_fixingDate(self, *args)
    def currency(self): return _QuantLib.InterestRateIndex_currency(self)
    def dayCounter(self): return _QuantLib.InterestRateIndex_dayCounter(self)
    def maturityDate(self, *args): return _QuantLib.InterestRateIndex_maturityDate(self, *args)
    def valueDate(self, *args): return _QuantLib.InterestRateIndex_valueDate(self, *args)
    __swig_destroy__ = _QuantLib.delete_InterestRateIndex
    __del__ = lambda self : None;
InterestRateIndex_swigregister = _QuantLib.InterestRateIndex_swigregister
InterestRateIndex_swigregister(InterestRateIndex)

class IborIndex(InterestRateIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_IborIndex(*args)
        try: self.this.append(this)
        except: self.this = this
    def businessDayConvention(self): return _QuantLib.IborIndex_businessDayConvention(self)
    def endOfMonth(self): return _QuantLib.IborIndex_endOfMonth(self)
    def forwardingTermStructure(self): return _QuantLib.IborIndex_forwardingTermStructure(self)
    __swig_destroy__ = _QuantLib.delete_IborIndex
    __del__ = lambda self : None;
IborIndex_swigregister = _QuantLib.IborIndex_swigregister
IborIndex_swigregister(IborIndex)

class SwapIndex(InterestRateIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SwapIndex(*args)
        try: self.this.append(this)
        except: self.this = this
    def fixedLegTenor(self): return _QuantLib.SwapIndex_fixedLegTenor(self)
    def fixedLegConvention(self): return _QuantLib.SwapIndex_fixedLegConvention(self)
    def iborIndex(self): return _QuantLib.SwapIndex_iborIndex(self)
    def forwardingTermStructure(self): return _QuantLib.SwapIndex_forwardingTermStructure(self)
    __swig_destroy__ = _QuantLib.delete_SwapIndex
    __del__ = lambda self : None;
SwapIndex_swigregister = _QuantLib.SwapIndex_swigregister
SwapIndex_swigregister(SwapIndex)

class AUDLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AUDLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AUDLibor
    __del__ = lambda self : None;
AUDLibor_swigregister = _QuantLib.AUDLibor_swigregister
AUDLibor_swigregister(AUDLibor)

class CADLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CADLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CADLibor
    __del__ = lambda self : None;
CADLibor_swigregister = _QuantLib.CADLibor_swigregister
CADLibor_swigregister(CADLibor)

class Cdor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Cdor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Cdor
    __del__ = lambda self : None;
Cdor_swigregister = _QuantLib.Cdor_swigregister
Cdor_swigregister(Cdor)

class CHFLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CHFLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CHFLibor
    __del__ = lambda self : None;
CHFLibor_swigregister = _QuantLib.CHFLibor_swigregister
CHFLibor_swigregister(CHFLibor)

class DKKLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DKKLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DKKLibor
    __del__ = lambda self : None;
DKKLibor_swigregister = _QuantLib.DKKLibor_swigregister
DKKLibor_swigregister(DKKLibor)

class Euribor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor
    __del__ = lambda self : None;
Euribor_swigregister = _QuantLib.Euribor_swigregister
Euribor_swigregister(Euribor)

class EuriborSW(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EuriborSW(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSW
    __del__ = lambda self : None;
EuriborSW_swigregister = _QuantLib.EuriborSW_swigregister
EuriborSW_swigregister(EuriborSW)

class Euribor2W(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor2W(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor2W
    __del__ = lambda self : None;
Euribor2W_swigregister = _QuantLib.Euribor2W_swigregister
Euribor2W_swigregister(Euribor2W)

class Euribor3W(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor3W(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor3W
    __del__ = lambda self : None;
Euribor3W_swigregister = _QuantLib.Euribor3W_swigregister
Euribor3W_swigregister(Euribor3W)

class Euribor1M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor1M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor1M
    __del__ = lambda self : None;
Euribor1M_swigregister = _QuantLib.Euribor1M_swigregister
Euribor1M_swigregister(Euribor1M)

class Euribor2M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor2M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor2M
    __del__ = lambda self : None;
Euribor2M_swigregister = _QuantLib.Euribor2M_swigregister
Euribor2M_swigregister(Euribor2M)

class Euribor3M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor3M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor3M
    __del__ = lambda self : None;
Euribor3M_swigregister = _QuantLib.Euribor3M_swigregister
Euribor3M_swigregister(Euribor3M)

class Euribor4M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor4M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor4M
    __del__ = lambda self : None;
Euribor4M_swigregister = _QuantLib.Euribor4M_swigregister
Euribor4M_swigregister(Euribor4M)

class Euribor5M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor5M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor5M
    __del__ = lambda self : None;
Euribor5M_swigregister = _QuantLib.Euribor5M_swigregister
Euribor5M_swigregister(Euribor5M)

class Euribor6M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor6M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor6M
    __del__ = lambda self : None;
Euribor6M_swigregister = _QuantLib.Euribor6M_swigregister
Euribor6M_swigregister(Euribor6M)

class Euribor7M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor7M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor7M
    __del__ = lambda self : None;
Euribor7M_swigregister = _QuantLib.Euribor7M_swigregister
Euribor7M_swigregister(Euribor7M)

class Euribor8M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor8M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor8M
    __del__ = lambda self : None;
Euribor8M_swigregister = _QuantLib.Euribor8M_swigregister
Euribor8M_swigregister(Euribor8M)

class Euribor9M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor9M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor9M
    __del__ = lambda self : None;
Euribor9M_swigregister = _QuantLib.Euribor9M_swigregister
Euribor9M_swigregister(Euribor9M)

class Euribor10M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor10M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor10M
    __del__ = lambda self : None;
Euribor10M_swigregister = _QuantLib.Euribor10M_swigregister
Euribor10M_swigregister(Euribor10M)

class Euribor11M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor11M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor11M
    __del__ = lambda self : None;
Euribor11M_swigregister = _QuantLib.Euribor11M_swigregister
Euribor11M_swigregister(Euribor11M)

class Euribor1Y(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor1Y(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor1Y
    __del__ = lambda self : None;
Euribor1Y_swigregister = _QuantLib.Euribor1Y_swigregister
Euribor1Y_swigregister(Euribor1Y)

class Euribor365(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365
    __del__ = lambda self : None;
Euribor365_swigregister = _QuantLib.Euribor365_swigregister
Euribor365_swigregister(Euribor365)

class Euribor365_SW(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_SW(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_SW
    __del__ = lambda self : None;
Euribor365_SW_swigregister = _QuantLib.Euribor365_SW_swigregister
Euribor365_SW_swigregister(Euribor365_SW)

class Euribor365_2W(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_2W(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_2W
    __del__ = lambda self : None;
Euribor365_2W_swigregister = _QuantLib.Euribor365_2W_swigregister
Euribor365_2W_swigregister(Euribor365_2W)

class Euribor365_3W(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_3W(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_3W
    __del__ = lambda self : None;
Euribor365_3W_swigregister = _QuantLib.Euribor365_3W_swigregister
Euribor365_3W_swigregister(Euribor365_3W)

class Euribor365_1M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_1M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_1M
    __del__ = lambda self : None;
Euribor365_1M_swigregister = _QuantLib.Euribor365_1M_swigregister
Euribor365_1M_swigregister(Euribor365_1M)

class Euribor365_2M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_2M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_2M
    __del__ = lambda self : None;
Euribor365_2M_swigregister = _QuantLib.Euribor365_2M_swigregister
Euribor365_2M_swigregister(Euribor365_2M)

class Euribor365_3M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_3M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_3M
    __del__ = lambda self : None;
Euribor365_3M_swigregister = _QuantLib.Euribor365_3M_swigregister
Euribor365_3M_swigregister(Euribor365_3M)

class Euribor365_4M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_4M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_4M
    __del__ = lambda self : None;
Euribor365_4M_swigregister = _QuantLib.Euribor365_4M_swigregister
Euribor365_4M_swigregister(Euribor365_4M)

class Euribor365_5M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_5M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_5M
    __del__ = lambda self : None;
Euribor365_5M_swigregister = _QuantLib.Euribor365_5M_swigregister
Euribor365_5M_swigregister(Euribor365_5M)

class Euribor365_6M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_6M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_6M
    __del__ = lambda self : None;
Euribor365_6M_swigregister = _QuantLib.Euribor365_6M_swigregister
Euribor365_6M_swigregister(Euribor365_6M)

class Euribor365_7M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_7M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_7M
    __del__ = lambda self : None;
Euribor365_7M_swigregister = _QuantLib.Euribor365_7M_swigregister
Euribor365_7M_swigregister(Euribor365_7M)

class Euribor365_8M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_8M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_8M
    __del__ = lambda self : None;
Euribor365_8M_swigregister = _QuantLib.Euribor365_8M_swigregister
Euribor365_8M_swigregister(Euribor365_8M)

class Euribor365_9M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_9M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_9M
    __del__ = lambda self : None;
Euribor365_9M_swigregister = _QuantLib.Euribor365_9M_swigregister
Euribor365_9M_swigregister(Euribor365_9M)

class Euribor365_10M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_10M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_10M
    __del__ = lambda self : None;
Euribor365_10M_swigregister = _QuantLib.Euribor365_10M_swigregister
Euribor365_10M_swigregister(Euribor365_10M)

class Euribor365_11M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_11M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_11M
    __del__ = lambda self : None;
Euribor365_11M_swigregister = _QuantLib.Euribor365_11M_swigregister
Euribor365_11M_swigregister(Euribor365_11M)

class Euribor365_1Y(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Euribor365_1Y(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_1Y
    __del__ = lambda self : None;
Euribor365_1Y_swigregister = _QuantLib.Euribor365_1Y_swigregister
Euribor365_1Y_swigregister(Euribor365_1Y)

class EURLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor
    __del__ = lambda self : None;
EURLibor_swigregister = _QuantLib.EURLibor_swigregister
EURLibor_swigregister(EURLibor)

class EURLiborSW(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLiborSW(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLiborSW
    __del__ = lambda self : None;
EURLiborSW_swigregister = _QuantLib.EURLiborSW_swigregister
EURLiborSW_swigregister(EURLiborSW)

class EURLibor2W(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor2W(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor2W
    __del__ = lambda self : None;
EURLibor2W_swigregister = _QuantLib.EURLibor2W_swigregister
EURLibor2W_swigregister(EURLibor2W)

class EURLibor1M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor1M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor1M
    __del__ = lambda self : None;
EURLibor1M_swigregister = _QuantLib.EURLibor1M_swigregister
EURLibor1M_swigregister(EURLibor1M)

class EURLibor2M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor2M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor2M
    __del__ = lambda self : None;
EURLibor2M_swigregister = _QuantLib.EURLibor2M_swigregister
EURLibor2M_swigregister(EURLibor2M)

class EURLibor3M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor3M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor3M
    __del__ = lambda self : None;
EURLibor3M_swigregister = _QuantLib.EURLibor3M_swigregister
EURLibor3M_swigregister(EURLibor3M)

class EURLibor4M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor4M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor4M
    __del__ = lambda self : None;
EURLibor4M_swigregister = _QuantLib.EURLibor4M_swigregister
EURLibor4M_swigregister(EURLibor4M)

class EURLibor5M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor5M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor5M
    __del__ = lambda self : None;
EURLibor5M_swigregister = _QuantLib.EURLibor5M_swigregister
EURLibor5M_swigregister(EURLibor5M)

class EURLibor6M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor6M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor6M
    __del__ = lambda self : None;
EURLibor6M_swigregister = _QuantLib.EURLibor6M_swigregister
EURLibor6M_swigregister(EURLibor6M)

class EURLibor7M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor7M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor7M
    __del__ = lambda self : None;
EURLibor7M_swigregister = _QuantLib.EURLibor7M_swigregister
EURLibor7M_swigregister(EURLibor7M)

class EURLibor8M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor8M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor8M
    __del__ = lambda self : None;
EURLibor8M_swigregister = _QuantLib.EURLibor8M_swigregister
EURLibor8M_swigregister(EURLibor8M)

class EURLibor9M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor9M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor9M
    __del__ = lambda self : None;
EURLibor9M_swigregister = _QuantLib.EURLibor9M_swigregister
EURLibor9M_swigregister(EURLibor9M)

class EURLibor10M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor10M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor10M
    __del__ = lambda self : None;
EURLibor10M_swigregister = _QuantLib.EURLibor10M_swigregister
EURLibor10M_swigregister(EURLibor10M)

class EURLibor11M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor11M(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor11M
    __del__ = lambda self : None;
EURLibor11M_swigregister = _QuantLib.EURLibor11M_swigregister
EURLibor11M_swigregister(EURLibor11M)

class EURLibor1Y(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EURLibor1Y(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor1Y
    __del__ = lambda self : None;
EURLibor1Y_swigregister = _QuantLib.EURLibor1Y_swigregister
EURLibor1Y_swigregister(EURLibor1Y)

class GBPLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GBPLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_GBPLibor
    __del__ = lambda self : None;
GBPLibor_swigregister = _QuantLib.GBPLibor_swigregister
GBPLibor_swigregister(GBPLibor)

class Jibar(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Jibar(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Jibar
    __del__ = lambda self : None;
Jibar_swigregister = _QuantLib.Jibar_swigregister
Jibar_swigregister(Jibar)

class JPYLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_JPYLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_JPYLibor
    __del__ = lambda self : None;
JPYLibor_swigregister = _QuantLib.JPYLibor_swigregister
JPYLibor_swigregister(JPYLibor)

class NZDLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_NZDLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NZDLibor
    __del__ = lambda self : None;
NZDLibor_swigregister = _QuantLib.NZDLibor_swigregister
NZDLibor_swigregister(NZDLibor)

class SEKLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SEKLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SEKLibor
    __del__ = lambda self : None;
SEKLibor_swigregister = _QuantLib.SEKLibor_swigregister
SEKLibor_swigregister(SEKLibor)

class Tibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Tibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Tibor
    __del__ = lambda self : None;
Tibor_swigregister = _QuantLib.Tibor_swigregister
Tibor_swigregister(Tibor)

class TRLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TRLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TRLibor
    __del__ = lambda self : None;
TRLibor_swigregister = _QuantLib.TRLibor_swigregister
TRLibor_swigregister(TRLibor)

class USDLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_USDLibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_USDLibor
    __del__ = lambda self : None;
USDLibor_swigregister = _QuantLib.USDLibor_swigregister
USDLibor_swigregister(USDLibor)

class Zibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Zibor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Zibor
    __del__ = lambda self : None;
Zibor_swigregister = _QuantLib.Zibor_swigregister
Zibor_swigregister(Zibor)

class EuriborSwapIsdaFixA(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EuriborSwapIsdaFixA(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixA
    __del__ = lambda self : None;
EuriborSwapIsdaFixA_swigregister = _QuantLib.EuriborSwapIsdaFixA_swigregister
EuriborSwapIsdaFixA_swigregister(EuriborSwapIsdaFixA)

class EuriborSwapIsdaFixB(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EuriborSwapIsdaFixB(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixB
    __del__ = lambda self : None;
EuriborSwapIsdaFixB_swigregister = _QuantLib.EuriborSwapIsdaFixB_swigregister
EuriborSwapIsdaFixB_swigregister(EuriborSwapIsdaFixB)

class EuriborSwapIfrFix(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EuriborSwapIfrFix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIfrFix
    __del__ = lambda self : None;
EuriborSwapIfrFix_swigregister = _QuantLib.EuriborSwapIfrFix_swigregister
EuriborSwapIfrFix_swigregister(EuriborSwapIfrFix)

class EurLiborSwapIsdaFixA(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EurLiborSwapIsdaFixA(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixA
    __del__ = lambda self : None;
EurLiborSwapIsdaFixA_swigregister = _QuantLib.EurLiborSwapIsdaFixA_swigregister
EurLiborSwapIsdaFixA_swigregister(EurLiborSwapIsdaFixA)

class EurLiborSwapIsdaFixB(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EurLiborSwapIsdaFixB(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixB
    __del__ = lambda self : None;
EurLiborSwapIsdaFixB_swigregister = _QuantLib.EurLiborSwapIsdaFixB_swigregister
EurLiborSwapIsdaFixB_swigregister(EurLiborSwapIsdaFixB)

class EurLiborSwapIfrFix(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_EurLiborSwapIfrFix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIfrFix
    __del__ = lambda self : None;
EurLiborSwapIfrFix_swigregister = _QuantLib.EurLiborSwapIfrFix_swigregister
EurLiborSwapIfrFix_swigregister(EurLiborSwapIfrFix)

class DateGeneration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Backward = _QuantLib.DateGeneration_Backward
    Forward = _QuantLib.DateGeneration_Forward
    Zero = _QuantLib.DateGeneration_Zero
    ThirdWednesday = _QuantLib.DateGeneration_ThirdWednesday
    Twentieth = _QuantLib.DateGeneration_Twentieth
    TwentiethIMM = _QuantLib.DateGeneration_TwentiethIMM
    OldCDS = _QuantLib.DateGeneration_OldCDS
    def __init__(self): 
        this = _QuantLib.new_DateGeneration()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DateGeneration
    __del__ = lambda self : None;
DateGeneration_swigregister = _QuantLib.DateGeneration_swigregister
DateGeneration_swigregister(DateGeneration)

class Schedule(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Schedule(*args)
        try: self.this.append(this)
        except: self.this = this
    def __len__(self): return _QuantLib.Schedule___len__(self)
    def isRegular(self, *args): return _QuantLib.Schedule_isRegular(self, *args)
    def __getitem__(self, *args): return _QuantLib.Schedule___getitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Schedule
    __del__ = lambda self : None;
Schedule_swigregister = _QuantLib.Schedule_swigregister
Schedule_swigregister(Schedule)

class CashFlow(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.CashFlow___deref__(self)
    def __nonzero__(self): return _QuantLib.CashFlow___nonzero__(self)
    def asObservable(self): return _QuantLib.CashFlow_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_CashFlow()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CashFlow
    __del__ = lambda self : None;
    def amount(self): return _QuantLib.CashFlow_amount(self)
    def date(self): return _QuantLib.CashFlow_date(self)
CashFlow_swigregister = _QuantLib.CashFlow_swigregister
CashFlow_swigregister(CashFlow)

class SimpleCashFlow(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SimpleCashFlow(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SimpleCashFlow
    __del__ = lambda self : None;
SimpleCashFlow_swigregister = _QuantLib.SimpleCashFlow_swigregister
SimpleCashFlow_swigregister(SimpleCashFlow)

class FixedRateCoupon(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FixedRateCoupon(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FixedRateCoupon
    __del__ = lambda self : None;
FixedRateCoupon_swigregister = _QuantLib.FixedRateCoupon_swigregister
FixedRateCoupon_swigregister(FixedRateCoupon)

class IborCoupon(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_IborCoupon(*args)
        try: self.this.append(this)
        except: self.this = this
    def rate(self): return _QuantLib.IborCoupon_rate(self)
    def indexFixing(self): return _QuantLib.IborCoupon_indexFixing(self)
    def nominal(self): return _QuantLib.IborCoupon_nominal(self)
    __swig_destroy__ = _QuantLib.delete_IborCoupon
    __del__ = lambda self : None;
IborCoupon_swigregister = _QuantLib.IborCoupon_swigregister
IborCoupon_swigregister(IborCoupon)

class FloatingRateCoupon(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def rate(self): return _QuantLib.FloatingRateCoupon_rate(self)
    def fixingDays(self): return _QuantLib.FloatingRateCoupon_fixingDays(self)
    def spread(self): return _QuantLib.FloatingRateCoupon_spread(self)
    def indexFixing(self): return _QuantLib.FloatingRateCoupon_indexFixing(self)
    def fixingDate(self): return _QuantLib.FloatingRateCoupon_fixingDate(self)
    def __init__(self): 
        this = _QuantLib.new_FloatingRateCoupon()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FloatingRateCoupon
    __del__ = lambda self : None;
FloatingRateCoupon_swigregister = _QuantLib.FloatingRateCoupon_swigregister
FloatingRateCoupon_swigregister(FloatingRateCoupon)

class Leg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.Leg_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.Leg___nonzero__(self)
    def __bool__(self): return _QuantLib.Leg___bool__(self)
    def __len__(self): return _QuantLib.Leg___len__(self)
    def pop(self): return _QuantLib.Leg_pop(self)
    def __getslice__(self, *args): return _QuantLib.Leg___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.Leg___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.Leg___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.Leg___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.Leg___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.Leg___setitem__(self, *args)
    def append(self, *args): return _QuantLib.Leg_append(self, *args)
    def empty(self): return _QuantLib.Leg_empty(self)
    def size(self): return _QuantLib.Leg_size(self)
    def clear(self): return _QuantLib.Leg_clear(self)
    def swap(self, *args): return _QuantLib.Leg_swap(self, *args)
    def get_allocator(self): return _QuantLib.Leg_get_allocator(self)
    def begin(self): return _QuantLib.Leg_begin(self)
    def end(self): return _QuantLib.Leg_end(self)
    def rbegin(self): return _QuantLib.Leg_rbegin(self)
    def rend(self): return _QuantLib.Leg_rend(self)
    def pop_back(self): return _QuantLib.Leg_pop_back(self)
    def erase(self, *args): return _QuantLib.Leg_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_Leg(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.Leg_push_back(self, *args)
    def front(self): return _QuantLib.Leg_front(self)
    def back(self): return _QuantLib.Leg_back(self)
    def assign(self, *args): return _QuantLib.Leg_assign(self, *args)
    def resize(self, *args): return _QuantLib.Leg_resize(self, *args)
    def insert(self, *args): return _QuantLib.Leg_insert(self, *args)
    def reserve(self, *args): return _QuantLib.Leg_reserve(self, *args)
    def capacity(self): return _QuantLib.Leg_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Leg
    __del__ = lambda self : None;
Leg_swigregister = _QuantLib.Leg_swigregister
Leg_swigregister(Leg)


def FixedRateLeg(*args, **kwargs):
  return _QuantLib.FixedRateLeg(*args, **kwargs)
FixedRateLeg = _QuantLib.FixedRateLeg

def IborLeg(*args, **kwargs):
  return _QuantLib.IborLeg(*args, **kwargs)
IborLeg = _QuantLib.IborLeg

def CmsLeg(*args, **kwargs):
  return _QuantLib.CmsLeg(*args, **kwargs)
CmsLeg = _QuantLib.CmsLeg

def CmsZeroLeg(*args, **kwargs):
  return _QuantLib.CmsZeroLeg(*args, **kwargs)
CmsZeroLeg = _QuantLib.CmsZeroLeg
class Duration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Simple = _QuantLib.Duration_Simple
    Macaulay = _QuantLib.Duration_Macaulay
    Modified = _QuantLib.Duration_Modified
    def __init__(self): 
        this = _QuantLib.new_Duration()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Duration
    __del__ = lambda self : None;
Duration_swigregister = _QuantLib.Duration_swigregister
Duration_swigregister(Duration)

class CashFlows(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    startDate = staticmethod(_QuantLib.CashFlows_startDate)
    maturityDate = staticmethod(_QuantLib.CashFlows_maturityDate)
    npv = staticmethod(_QuantLib.CashFlows_npv)
    bps = staticmethod(_QuantLib.CashFlows_bps)
    atmRate = staticmethod(_QuantLib.CashFlows_atmRate)
    _yield = staticmethod(_QuantLib.CashFlows__yield)
    duration = staticmethod(_QuantLib.CashFlows_duration)
    convexity = staticmethod(_QuantLib.CashFlows_convexity)
    __swig_destroy__ = _QuantLib.delete_CashFlows
    __del__ = lambda self : None;
CashFlows_swigregister = _QuantLib.CashFlows_swigregister
CashFlows_swigregister(CashFlows)

def CashFlows_startDate(*args):
  return _QuantLib.CashFlows_startDate(*args)
CashFlows_startDate = _QuantLib.CashFlows_startDate

def CashFlows_maturityDate(*args):
  return _QuantLib.CashFlows_maturityDate(*args)
CashFlows_maturityDate = _QuantLib.CashFlows_maturityDate

def CashFlows_npv(*args):
  return _QuantLib.CashFlows_npv(*args)
CashFlows_npv = _QuantLib.CashFlows_npv

def CashFlows_bps(*args):
  return _QuantLib.CashFlows_bps(*args)
CashFlows_bps = _QuantLib.CashFlows_bps

def CashFlows_atmRate(*args):
  return _QuantLib.CashFlows_atmRate(*args)
CashFlows_atmRate = _QuantLib.CashFlows_atmRate

def CashFlows__yield(*args):
  return _QuantLib.CashFlows__yield(*args)
CashFlows__yield = _QuantLib.CashFlows__yield

def CashFlows_duration(*args):
  return _QuantLib.CashFlows_duration(*args)
CashFlows_duration = _QuantLib.CashFlows_duration

def CashFlows_convexity(*args):
  return _QuantLib.CashFlows_convexity(*args)
CashFlows_convexity = _QuantLib.CashFlows_convexity

class Bond(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def nextCouponRate(self, *args): return _QuantLib.Bond_nextCouponRate(self, *args)
    def previousCouponRate(self, *args): return _QuantLib.Bond_previousCouponRate(self, *args)
    def settlementDays(self): return _QuantLib.Bond_settlementDays(self)
    def settlementDate(self): return _QuantLib.Bond_settlementDate(self)
    def maturityDate(self): return _QuantLib.Bond_maturityDate(self)
    def issueDate(self): return _QuantLib.Bond_issueDate(self)
    def cashflows(self): return _QuantLib.Bond_cashflows(self)
    def redemptions(self): return _QuantLib.Bond_redemptions(self)
    def redemption(self): return _QuantLib.Bond_redemption(self)
    def calendar(self): return _QuantLib.Bond_calendar(self)
    def notionals(self): return _QuantLib.Bond_notionals(self)
    def notional(self, *args): return _QuantLib.Bond_notional(self, *args)
    def cleanPrice(self, *args): return _QuantLib.Bond_cleanPrice(self, *args)
    def dirtyPrice(self, *args): return _QuantLib.Bond_dirtyPrice(self, *args)
    def bondYield(self, *args): return _QuantLib.Bond_bondYield(self, *args)
    def accruedAmount(self, *args): return _QuantLib.Bond_accruedAmount(self, *args)
    def settlementValue(self, *args): return _QuantLib.Bond_settlementValue(self, *args)
    __swig_destroy__ = _QuantLib.delete_Bond
    __del__ = lambda self : None;
Bond_swigregister = _QuantLib.Bond_swigregister
Bond_swigregister(Bond)

class ZeroCouponBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_ZeroCouponBond(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroCouponBond
    __del__ = lambda self : None;
ZeroCouponBond_swigregister = _QuantLib.ZeroCouponBond_swigregister
ZeroCouponBond_swigregister(ZeroCouponBond)

def cleanPriceFromZSpread(*args):
  return _QuantLib.cleanPriceFromZSpread(*args)
cleanPriceFromZSpread = _QuantLib.cleanPriceFromZSpread

class FixedRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_FixedRateBond(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    def frequency(self): return _QuantLib.FixedRateBond_frequency(self)
    def dayCounter(self): return _QuantLib.FixedRateBond_dayCounter(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBond
    __del__ = lambda self : None;
FixedRateBond_swigregister = _QuantLib.FixedRateBond_swigregister
FixedRateBond_swigregister(FixedRateBond)

class FloatingRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        this = _QuantLib.new_FloatingRateBond(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FloatingRateBond
    __del__ = lambda self : None;
FloatingRateBond_swigregister = _QuantLib.FloatingRateBond_swigregister
FloatingRateBond_swigregister(FloatingRateBond)

class DiscountingBondEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DiscountingBondEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DiscountingBondEngine
    __del__ = lambda self : None;
DiscountingBondEngine_swigregister = _QuantLib.DiscountingBondEngine_swigregister
DiscountingBondEngine_swigregister(DiscountingBondEngine)

class CallabilityPrice(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Dirty = _QuantLib.CallabilityPrice_Dirty
    Clean = _QuantLib.CallabilityPrice_Clean
    def __init__(self, *args): 
        this = _QuantLib.new_CallabilityPrice(*args)
        try: self.this.append(this)
        except: self.this = this
    def amount(self): return _QuantLib.CallabilityPrice_amount(self)
    def type(self): return _QuantLib.CallabilityPrice_type(self)
    __swig_destroy__ = _QuantLib.delete_CallabilityPrice
    __del__ = lambda self : None;
CallabilityPrice_swigregister = _QuantLib.CallabilityPrice_swigregister
CallabilityPrice_swigregister(CallabilityPrice)

class Callability(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Callability___deref__(self)
    def __nonzero__(self): return _QuantLib.Callability___nonzero__(self)
    def __init__(self, *args): 
        this = _QuantLib.new_Callability(*args)
        try: self.this.append(this)
        except: self.this = this
    Call = _QuantLib.Callability_Call
    Put = _QuantLib.Callability_Put
    __swig_destroy__ = _QuantLib.delete_Callability
    __del__ = lambda self : None;
    def price(self): return _QuantLib.Callability_price(self)
    def type(self): return _QuantLib.Callability_type(self)
    def date(self): return _QuantLib.Callability_date(self)
Callability_swigregister = _QuantLib.Callability_swigregister
Callability_swigregister(Callability)

class SoftCallability(Callability):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SoftCallability(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SoftCallability
    __del__ = lambda self : None;
SoftCallability_swigregister = _QuantLib.SoftCallability_swigregister
SoftCallability_swigregister(SoftCallability)

class CallabilitySchedule(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.CallabilitySchedule_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.CallabilitySchedule___nonzero__(self)
    def __bool__(self): return _QuantLib.CallabilitySchedule___bool__(self)
    def __len__(self): return _QuantLib.CallabilitySchedule___len__(self)
    def pop(self): return _QuantLib.CallabilitySchedule_pop(self)
    def __getslice__(self, *args): return _QuantLib.CallabilitySchedule___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.CallabilitySchedule___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.CallabilitySchedule___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.CallabilitySchedule___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.CallabilitySchedule___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.CallabilitySchedule___setitem__(self, *args)
    def append(self, *args): return _QuantLib.CallabilitySchedule_append(self, *args)
    def empty(self): return _QuantLib.CallabilitySchedule_empty(self)
    def size(self): return _QuantLib.CallabilitySchedule_size(self)
    def clear(self): return _QuantLib.CallabilitySchedule_clear(self)
    def swap(self, *args): return _QuantLib.CallabilitySchedule_swap(self, *args)
    def get_allocator(self): return _QuantLib.CallabilitySchedule_get_allocator(self)
    def begin(self): return _QuantLib.CallabilitySchedule_begin(self)
    def end(self): return _QuantLib.CallabilitySchedule_end(self)
    def rbegin(self): return _QuantLib.CallabilitySchedule_rbegin(self)
    def rend(self): return _QuantLib.CallabilitySchedule_rend(self)
    def pop_back(self): return _QuantLib.CallabilitySchedule_pop_back(self)
    def erase(self, *args): return _QuantLib.CallabilitySchedule_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_CallabilitySchedule(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.CallabilitySchedule_push_back(self, *args)
    def front(self): return _QuantLib.CallabilitySchedule_front(self)
    def back(self): return _QuantLib.CallabilitySchedule_back(self)
    def assign(self, *args): return _QuantLib.CallabilitySchedule_assign(self, *args)
    def resize(self, *args): return _QuantLib.CallabilitySchedule_resize(self, *args)
    def insert(self, *args): return _QuantLib.CallabilitySchedule_insert(self, *args)
    def reserve(self, *args): return _QuantLib.CallabilitySchedule_reserve(self, *args)
    def capacity(self): return _QuantLib.CallabilitySchedule_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CallabilitySchedule
    __del__ = lambda self : None;
CallabilitySchedule_swigregister = _QuantLib.CallabilitySchedule_swigregister
CallabilitySchedule_swigregister(CallabilitySchedule)

class CapFloor(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def impliedVolatility(self, *args): return _QuantLib.CapFloor_impliedVolatility(self, *args)
    def __init__(self): 
        this = _QuantLib.new_CapFloor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloor
    __del__ = lambda self : None;
CapFloor_swigregister = _QuantLib.CapFloor_swigregister
CapFloor_swigregister(CapFloor)

class Cap(CapFloor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Cap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Cap
    __del__ = lambda self : None;
Cap_swigregister = _QuantLib.Cap_swigregister
Cap_swigregister(Cap)

class Floor(CapFloor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Floor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Floor
    __del__ = lambda self : None;
Floor_swigregister = _QuantLib.Floor_swigregister
Floor_swigregister(Floor)

class Collar(CapFloor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Collar(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Collar
    __del__ = lambda self : None;
Collar_swigregister = _QuantLib.Collar_swigregister
Collar_swigregister(Collar)

class BlackCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackCapFloorEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackCapFloorEngine
    __del__ = lambda self : None;
BlackCapFloorEngine_swigregister = _QuantLib.BlackCapFloorEngine_swigregister
BlackCapFloorEngine_swigregister(BlackCapFloorEngine)

class Dividend(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Dividend___deref__(self)
    def __nonzero__(self): return _QuantLib.Dividend___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_Dividend()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Dividend
    __del__ = lambda self : None;
    def amount(self): return _QuantLib.Dividend_amount(self)
    def date(self): return _QuantLib.Dividend_date(self)
Dividend_swigregister = _QuantLib.Dividend_swigregister
Dividend_swigregister(Dividend)

class FixedDividend(Dividend):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FixedDividend(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FixedDividend
    __del__ = lambda self : None;
FixedDividend_swigregister = _QuantLib.FixedDividend_swigregister
FixedDividend_swigregister(FixedDividend)

class FractionalDividend(Dividend):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FractionalDividend(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FractionalDividend
    __del__ = lambda self : None;
FractionalDividend_swigregister = _QuantLib.FractionalDividend_swigregister
FractionalDividend_swigregister(FractionalDividend)

class DividendSchedule(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.DividendSchedule_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.DividendSchedule___nonzero__(self)
    def __bool__(self): return _QuantLib.DividendSchedule___bool__(self)
    def __len__(self): return _QuantLib.DividendSchedule___len__(self)
    def pop(self): return _QuantLib.DividendSchedule_pop(self)
    def __getslice__(self, *args): return _QuantLib.DividendSchedule___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.DividendSchedule___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.DividendSchedule___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.DividendSchedule___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.DividendSchedule___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.DividendSchedule___setitem__(self, *args)
    def append(self, *args): return _QuantLib.DividendSchedule_append(self, *args)
    def empty(self): return _QuantLib.DividendSchedule_empty(self)
    def size(self): return _QuantLib.DividendSchedule_size(self)
    def clear(self): return _QuantLib.DividendSchedule_clear(self)
    def swap(self, *args): return _QuantLib.DividendSchedule_swap(self, *args)
    def get_allocator(self): return _QuantLib.DividendSchedule_get_allocator(self)
    def begin(self): return _QuantLib.DividendSchedule_begin(self)
    def end(self): return _QuantLib.DividendSchedule_end(self)
    def rbegin(self): return _QuantLib.DividendSchedule_rbegin(self)
    def rend(self): return _QuantLib.DividendSchedule_rend(self)
    def pop_back(self): return _QuantLib.DividendSchedule_pop_back(self)
    def erase(self, *args): return _QuantLib.DividendSchedule_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_DividendSchedule(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.DividendSchedule_push_back(self, *args)
    def front(self): return _QuantLib.DividendSchedule_front(self)
    def back(self): return _QuantLib.DividendSchedule_back(self)
    def assign(self, *args): return _QuantLib.DividendSchedule_assign(self, *args)
    def resize(self, *args): return _QuantLib.DividendSchedule_resize(self, *args)
    def insert(self, *args): return _QuantLib.DividendSchedule_insert(self, *args)
    def reserve(self, *args): return _QuantLib.DividendSchedule_reserve(self, *args)
    def capacity(self): return _QuantLib.DividendSchedule_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DividendSchedule
    __del__ = lambda self : None;
DividendSchedule_swigregister = _QuantLib.DividendSchedule_swigregister
DividendSchedule_swigregister(DividendSchedule)

class ConvertibleZeroCouponBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ConvertibleZeroCouponBond(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ConvertibleZeroCouponBond
    __del__ = lambda self : None;
ConvertibleZeroCouponBond_swigregister = _QuantLib.ConvertibleZeroCouponBond_swigregister
ConvertibleZeroCouponBond_swigregister(ConvertibleZeroCouponBond)

class ConvertibleFixedCouponBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ConvertibleFixedCouponBond(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ConvertibleFixedCouponBond
    __del__ = lambda self : None;
ConvertibleFixedCouponBond_swigregister = _QuantLib.ConvertibleFixedCouponBond_swigregister
ConvertibleFixedCouponBond_swigregister(ConvertibleFixedCouponBond)

class ConvertibleFloatingRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ConvertibleFloatingRateBond(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ConvertibleFloatingRateBond
    __del__ = lambda self : None;
ConvertibleFloatingRateBond_swigregister = _QuantLib.ConvertibleFloatingRateBond_swigregister
ConvertibleFloatingRateBond_swigregister(ConvertibleFloatingRateBond)

class BinomialConvertibleEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BinomialConvertibleEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialConvertibleEngine
    __del__ = lambda self : None;
BinomialConvertibleEngine_swigregister = _QuantLib.BinomialConvertibleEngine_swigregister
BinomialConvertibleEngine_swigregister(BinomialConvertibleEngine)

class DefaultProbabilityTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.DefaultProbabilityTermStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.DefaultProbabilityTermStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.DefaultProbabilityTermStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_DefaultProbabilityTermStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructure
    __del__ = lambda self : None;
    def dayCounter(self): return _QuantLib.DefaultProbabilityTermStructure_dayCounter(self)
    def calendar(self): return _QuantLib.DefaultProbabilityTermStructure_calendar(self)
    def referenceDate(self): return _QuantLib.DefaultProbabilityTermStructure_referenceDate(self)
    def maxDate(self): return _QuantLib.DefaultProbabilityTermStructure_maxDate(self)
    def maxTime(self): return _QuantLib.DefaultProbabilityTermStructure_maxTime(self)
    def defaultProbability(self, *args): return _QuantLib.DefaultProbabilityTermStructure_defaultProbability(self, *args)
    def survivalProbability(self, *args): return _QuantLib.DefaultProbabilityTermStructure_survivalProbability(self, *args)
    def defaultDensity(self, *args): return _QuantLib.DefaultProbabilityTermStructure_defaultDensity(self, *args)
    def hazardRate(self, *args): return _QuantLib.DefaultProbabilityTermStructure_hazardRate(self, *args)
    def enableExtrapolation(self): return _QuantLib.DefaultProbabilityTermStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.DefaultProbabilityTermStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.DefaultProbabilityTermStructure_allowsExtrapolation(self)
DefaultProbabilityTermStructure_swigregister = _QuantLib.DefaultProbabilityTermStructure_swigregister
DefaultProbabilityTermStructure_swigregister(DefaultProbabilityTermStructure)

class DefaultProbabilityTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DefaultProbabilityTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.DefaultProbabilityTermStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.DefaultProbabilityTermStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.DefaultProbabilityTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructureHandle
    __del__ = lambda self : None;
    def dayCounter(self): return _QuantLib.DefaultProbabilityTermStructureHandle_dayCounter(self)
    def calendar(self): return _QuantLib.DefaultProbabilityTermStructureHandle_calendar(self)
    def referenceDate(self): return _QuantLib.DefaultProbabilityTermStructureHandle_referenceDate(self)
    def maxDate(self): return _QuantLib.DefaultProbabilityTermStructureHandle_maxDate(self)
    def maxTime(self): return _QuantLib.DefaultProbabilityTermStructureHandle_maxTime(self)
    def defaultProbability(self, *args): return _QuantLib.DefaultProbabilityTermStructureHandle_defaultProbability(self, *args)
    def survivalProbability(self, *args): return _QuantLib.DefaultProbabilityTermStructureHandle_survivalProbability(self, *args)
    def defaultDensity(self, *args): return _QuantLib.DefaultProbabilityTermStructureHandle_defaultDensity(self, *args)
    def hazardRate(self, *args): return _QuantLib.DefaultProbabilityTermStructureHandle_hazardRate(self, *args)
    def enableExtrapolation(self): return _QuantLib.DefaultProbabilityTermStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.DefaultProbabilityTermStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.DefaultProbabilityTermStructureHandle_allowsExtrapolation(self)
DefaultProbabilityTermStructureHandle_swigregister = _QuantLib.DefaultProbabilityTermStructureHandle_swigregister
DefaultProbabilityTermStructureHandle_swigregister(DefaultProbabilityTermStructureHandle)

class RelinkableDefaultProbabilityTermStructureHandle(DefaultProbabilityTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableDefaultProbabilityTermStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableDefaultProbabilityTermStructureHandle
    __del__ = lambda self : None;
RelinkableDefaultProbabilityTermStructureHandle_swigregister = _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_swigregister
RelinkableDefaultProbabilityTermStructureHandle_swigregister(RelinkableDefaultProbabilityTermStructureHandle)

class FlatHazardRate(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FlatHazardRate(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FlatHazardRate
    __del__ = lambda self : None;
FlatHazardRate_swigregister = _QuantLib.FlatHazardRate_swigregister
FlatHazardRate_swigregister(FlatHazardRate)

class HazardRateCurve(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_HazardRateCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.HazardRateCurve_dates(self)
    def hazardRates(self): return _QuantLib.HazardRateCurve_hazardRates(self)
    def nodes(self): return _QuantLib.HazardRateCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_HazardRateCurve
    __del__ = lambda self : None;
HazardRateCurve_swigregister = _QuantLib.HazardRateCurve_swigregister
HazardRateCurve_swigregister(HazardRateCurve)

class DefaultDensityCurve(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DefaultDensityCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.DefaultDensityCurve_dates(self)
    def defaultDensities(self): return _QuantLib.DefaultDensityCurve_defaultDensities(self)
    def nodes(self): return _QuantLib.DefaultDensityCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_DefaultDensityCurve
    __del__ = lambda self : None;
DefaultDensityCurve_swigregister = _QuantLib.DefaultDensityCurve_swigregister
DefaultDensityCurve_swigregister(DefaultDensityCurve)

class DefaultProbabilityHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.DefaultProbabilityHelper___deref__(self)
    def __nonzero__(self): return _QuantLib.DefaultProbabilityHelper___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_DefaultProbabilityHelper()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelper
    __del__ = lambda self : None;
DefaultProbabilityHelper_swigregister = _QuantLib.DefaultProbabilityHelper_swigregister
DefaultProbabilityHelper_swigregister(DefaultProbabilityHelper)

class DefaultProbabilityHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.DefaultProbabilityHelperVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.DefaultProbabilityHelperVector___nonzero__(self)
    def __bool__(self): return _QuantLib.DefaultProbabilityHelperVector___bool__(self)
    def __len__(self): return _QuantLib.DefaultProbabilityHelperVector___len__(self)
    def pop(self): return _QuantLib.DefaultProbabilityHelperVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.DefaultProbabilityHelperVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.DefaultProbabilityHelperVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.DefaultProbabilityHelperVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.DefaultProbabilityHelperVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.DefaultProbabilityHelperVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.DefaultProbabilityHelperVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.DefaultProbabilityHelperVector_append(self, *args)
    def empty(self): return _QuantLib.DefaultProbabilityHelperVector_empty(self)
    def size(self): return _QuantLib.DefaultProbabilityHelperVector_size(self)
    def clear(self): return _QuantLib.DefaultProbabilityHelperVector_clear(self)
    def swap(self, *args): return _QuantLib.DefaultProbabilityHelperVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.DefaultProbabilityHelperVector_get_allocator(self)
    def begin(self): return _QuantLib.DefaultProbabilityHelperVector_begin(self)
    def end(self): return _QuantLib.DefaultProbabilityHelperVector_end(self)
    def rbegin(self): return _QuantLib.DefaultProbabilityHelperVector_rbegin(self)
    def rend(self): return _QuantLib.DefaultProbabilityHelperVector_rend(self)
    def pop_back(self): return _QuantLib.DefaultProbabilityHelperVector_pop_back(self)
    def erase(self, *args): return _QuantLib.DefaultProbabilityHelperVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_DefaultProbabilityHelperVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.DefaultProbabilityHelperVector_push_back(self, *args)
    def front(self): return _QuantLib.DefaultProbabilityHelperVector_front(self)
    def back(self): return _QuantLib.DefaultProbabilityHelperVector_back(self)
    def assign(self, *args): return _QuantLib.DefaultProbabilityHelperVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.DefaultProbabilityHelperVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.DefaultProbabilityHelperVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.DefaultProbabilityHelperVector_reserve(self, *args)
    def capacity(self): return _QuantLib.DefaultProbabilityHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelperVector
    __del__ = lambda self : None;
DefaultProbabilityHelperVector_swigregister = _QuantLib.DefaultProbabilityHelperVector_swigregister
DefaultProbabilityHelperVector_swigregister(DefaultProbabilityHelperVector)

class SpreadCdsHelper(DefaultProbabilityHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SpreadCdsHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SpreadCdsHelper
    __del__ = lambda self : None;
SpreadCdsHelper_swigregister = _QuantLib.SpreadCdsHelper_swigregister
SpreadCdsHelper_swigregister(SpreadCdsHelper)

class UpfrontCdsHelper(DefaultProbabilityHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_UpfrontCdsHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_UpfrontCdsHelper
    __del__ = lambda self : None;
UpfrontCdsHelper_swigregister = _QuantLib.UpfrontCdsHelper_swigregister
UpfrontCdsHelper_swigregister(UpfrontCdsHelper)

class HazardRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_HazardRate()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_HazardRate
    __del__ = lambda self : None;
HazardRate_swigregister = _QuantLib.HazardRate_swigregister
HazardRate_swigregister(HazardRate)

class DefaultDensity(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_DefaultDensity()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultDensity
    __del__ = lambda self : None;
DefaultDensity_swigregister = _QuantLib.DefaultDensity_swigregister
DefaultDensity_swigregister(DefaultDensity)

class PiecewiseFlatHazardRate(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_PiecewiseFlatHazardRate(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.PiecewiseFlatHazardRate_dates(self)
    def times(self): return _QuantLib.PiecewiseFlatHazardRate_times(self)
    def nodes(self): return _QuantLib.PiecewiseFlatHazardRate_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseFlatHazardRate
    __del__ = lambda self : None;
PiecewiseFlatHazardRate_swigregister = _QuantLib.PiecewiseFlatHazardRate_swigregister
PiecewiseFlatHazardRate_swigregister(PiecewiseFlatHazardRate)

class Protection(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Buyer = _QuantLib.Protection_Buyer
    Seller = _QuantLib.Protection_Seller
    def __init__(self): 
        this = _QuantLib.new_Protection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Protection
    __del__ = lambda self : None;
Protection_swigregister = _QuantLib.Protection_swigregister
Protection_swigregister(Protection)

class CreditDefaultSwap(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CreditDefaultSwap(*args)
        try: self.this.append(this)
        except: self.this = this
    def side(self): return _QuantLib.CreditDefaultSwap_side(self)
    def notional(self): return _QuantLib.CreditDefaultSwap_notional(self)
    def runningSpread(self): return _QuantLib.CreditDefaultSwap_runningSpread(self)
    def upfront(self): return _QuantLib.CreditDefaultSwap_upfront(self)
    def settlesAccrual(self): return _QuantLib.CreditDefaultSwap_settlesAccrual(self)
    def paysAtDefaultTime(self): return _QuantLib.CreditDefaultSwap_paysAtDefaultTime(self)
    def fairSpread(self): return _QuantLib.CreditDefaultSwap_fairSpread(self)
    def fairUpfront(self): return _QuantLib.CreditDefaultSwap_fairUpfront(self)
    def couponLegBPS(self): return _QuantLib.CreditDefaultSwap_couponLegBPS(self)
    def couponLegNPV(self): return _QuantLib.CreditDefaultSwap_couponLegNPV(self)
    def defaultLegNPV(self): return _QuantLib.CreditDefaultSwap_defaultLegNPV(self)
    def upfrontBPS(self): return _QuantLib.CreditDefaultSwap_upfrontBPS(self)
    def upfrontNPV(self): return _QuantLib.CreditDefaultSwap_upfrontNPV(self)
    def impliedHazardRate(self, *args): return _QuantLib.CreditDefaultSwap_impliedHazardRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_CreditDefaultSwap
    __del__ = lambda self : None;
CreditDefaultSwap_swigregister = _QuantLib.CreditDefaultSwap_swigregister
CreditDefaultSwap_swigregister(CreditDefaultSwap)

class MidPointCdsEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MidPointCdsEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_MidPointCdsEngine
    __del__ = lambda self : None;
MidPointCdsEngine_swigregister = _QuantLib.MidPointCdsEngine_swigregister
MidPointCdsEngine_swigregister(MidPointCdsEngine)

class DiscountCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DiscountCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.DiscountCurve_dates(self)
    def discounts(self): return _QuantLib.DiscountCurve_discounts(self)
    def nodes(self): return _QuantLib.DiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_DiscountCurve
    __del__ = lambda self : None;
DiscountCurve_swigregister = _QuantLib.DiscountCurve_swigregister
DiscountCurve_swigregister(DiscountCurve)

class NormalDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, average = 0.0, sigma = 1.0): 
        this = _QuantLib.new_NormalDistribution(average, sigma)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.NormalDistribution___call__(self, *args)
    def derivative(self, *args): return _QuantLib.NormalDistribution_derivative(self, *args)
    __swig_destroy__ = _QuantLib.delete_NormalDistribution
    __del__ = lambda self : None;
NormalDistribution_swigregister = _QuantLib.NormalDistribution_swigregister
NormalDistribution_swigregister(NormalDistribution)

class CumulativeNormalDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, average = 0.0, sigma = 1.0): 
        this = _QuantLib.new_CumulativeNormalDistribution(average, sigma)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.CumulativeNormalDistribution___call__(self, *args)
    def derivative(self, *args): return _QuantLib.CumulativeNormalDistribution_derivative(self, *args)
    __swig_destroy__ = _QuantLib.delete_CumulativeNormalDistribution
    __del__ = lambda self : None;
CumulativeNormalDistribution_swigregister = _QuantLib.CumulativeNormalDistribution_swigregister
CumulativeNormalDistribution_swigregister(CumulativeNormalDistribution)

class InverseCumulativeNormal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, average = 0.0, sigma = 1.0): 
        this = _QuantLib.new_InverseCumulativeNormal(average, sigma)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.InverseCumulativeNormal___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeNormal
    __del__ = lambda self : None;
InverseCumulativeNormal_swigregister = _QuantLib.InverseCumulativeNormal_swigregister
InverseCumulativeNormal_swigregister(InverseCumulativeNormal)

class MoroInverseCumulativeNormal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, average = 0.0, sigma = 1.0): 
        this = _QuantLib.new_MoroInverseCumulativeNormal(average, sigma)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.MoroInverseCumulativeNormal___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_MoroInverseCumulativeNormal
    __del__ = lambda self : None;
MoroInverseCumulativeNormal_swigregister = _QuantLib.MoroInverseCumulativeNormal_swigregister
MoroInverseCumulativeNormal_swigregister(MoroInverseCumulativeNormal)

class BivariateCumulativeNormalDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BivariateCumulativeNormalDistribution(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.BivariateCumulativeNormalDistribution___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistribution
    __del__ = lambda self : None;
BivariateCumulativeNormalDistribution_swigregister = _QuantLib.BivariateCumulativeNormalDistribution_swigregister
BivariateCumulativeNormalDistribution_swigregister(BivariateCumulativeNormalDistribution)

class Money(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Money(*args)
        try: self.this.append(this)
        except: self.this = this
    def currency(self): return _QuantLib.Money_currency(self)
    def value(self): return _QuantLib.Money_value(self)
    def rounded(self): return _QuantLib.Money_rounded(self)
    def __pos__(self): return _QuantLib.Money___pos__(self)
    def __neg__(self): return _QuantLib.Money___neg__(self)
    def __add__(self, *args): return _QuantLib.Money___add__(self, *args)
    def __sub__(self, *args): return _QuantLib.Money___sub__(self, *args)
    def __mul__(self, *args): return _QuantLib.Money___mul__(self, *args)
    def __div__(self, *args): return _QuantLib.Money___div__(self, *args)
    def __rmul__(self, *args): return _QuantLib.Money___rmul__(self, *args)
    def __cmp__(self, *args): return _QuantLib.Money___cmp__(self, *args)
    def __str__(self): return _QuantLib.Money___str__(self)
    NoConversion = _QuantLib.Money_NoConversion
    BaseCurrencyConversion = _QuantLib.Money_BaseCurrencyConversion
    AutomatedConversion = _QuantLib.Money_AutomatedConversion
    setConversionType = staticmethod(_QuantLib.Money_setConversionType)
    setBaseCurrency = staticmethod(_QuantLib.Money_setBaseCurrency)
    __swig_destroy__ = _QuantLib.delete_Money
    __del__ = lambda self : None;
Money_swigregister = _QuantLib.Money_swigregister
Money_swigregister(Money)

def Money_setConversionType(*args):
  return _QuantLib.Money_setConversionType(*args)
Money_setConversionType = _QuantLib.Money_setConversionType

def Money_setBaseCurrency(*args):
  return _QuantLib.Money_setBaseCurrency(*args)
Money_setBaseCurrency = _QuantLib.Money_setBaseCurrency

class ExchangeRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Direct = _QuantLib.ExchangeRate_Direct
    Derived = _QuantLib.ExchangeRate_Derived
    def __init__(self, *args): 
        this = _QuantLib.new_ExchangeRate(*args)
        try: self.this.append(this)
        except: self.this = this
    def source(self): return _QuantLib.ExchangeRate_source(self)
    def target(self): return _QuantLib.ExchangeRate_target(self)
    def type(self): return _QuantLib.ExchangeRate_type(self)
    def rate(self): return _QuantLib.ExchangeRate_rate(self)
    def exchange(self, *args): return _QuantLib.ExchangeRate_exchange(self, *args)
    chain = staticmethod(_QuantLib.ExchangeRate_chain)
    __swig_destroy__ = _QuantLib.delete_ExchangeRate
    __del__ = lambda self : None;
ExchangeRate_swigregister = _QuantLib.ExchangeRate_swigregister
ExchangeRate_swigregister(ExchangeRate)

def ExchangeRate_chain(*args):
  return _QuantLib.ExchangeRate_chain(*args)
ExchangeRate_chain = _QuantLib.ExchangeRate_chain

class ExchangeRateManager(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    instance = staticmethod(_QuantLib.ExchangeRateManager_instance)
    def add(self, *args): return _QuantLib.ExchangeRateManager_add(self, *args)
    def lookup(self, *args): return _QuantLib.ExchangeRateManager_lookup(self, *args)
    def clear(self): return _QuantLib.ExchangeRateManager_clear(self)
    __swig_destroy__ = _QuantLib.delete_ExchangeRateManager
    __del__ = lambda self : None;
ExchangeRateManager_swigregister = _QuantLib.ExchangeRateManager_swigregister
ExchangeRateManager_swigregister(ExchangeRateManager)

def ExchangeRateManager_instance():
  return _QuantLib.ExchangeRateManager_instance()
ExchangeRateManager_instance = _QuantLib.ExchangeRateManager_instance

class ForwardCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ForwardCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.ForwardCurve_dates(self)
    def forwards(self): return _QuantLib.ForwardCurve_forwards(self)
    def nodes(self): return _QuantLib.ForwardCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ForwardCurve
    __del__ = lambda self : None;
ForwardCurve_swigregister = _QuantLib.ForwardCurve_swigregister
ForwardCurve_swigregister(ForwardCurve)

class TimeGrid(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TimeGrid(*args)
        try: self.this.append(this)
        except: self.this = this
    def __len__(self): return _QuantLib.TimeGrid___len__(self)
    def __getitem__(self, *args): return _QuantLib.TimeGrid___getitem__(self, *args)
    def dt(self, *args): return _QuantLib.TimeGrid_dt(self, *args)
    __swig_destroy__ = _QuantLib.delete_TimeGrid
    __del__ = lambda self : None;
TimeGrid_swigregister = _QuantLib.TimeGrid_swigregister
TimeGrid_swigregister(TimeGrid)

class SegmentIntegral(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SegmentIntegral(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.SegmentIntegral___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_SegmentIntegral
    __del__ = lambda self : None;
SegmentIntegral_swigregister = _QuantLib.SegmentIntegral_swigregister
SegmentIntegral_swigregister(SegmentIntegral)

class TrapezoidIntegralDefault(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TrapezoidIntegralDefault(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.TrapezoidIntegralDefault___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralDefault
    __del__ = lambda self : None;
TrapezoidIntegralDefault_swigregister = _QuantLib.TrapezoidIntegralDefault_swigregister
TrapezoidIntegralDefault_swigregister(TrapezoidIntegralDefault)

class TrapezoidIntegralMidPoint(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TrapezoidIntegralMidPoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.TrapezoidIntegralMidPoint___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralMidPoint
    __del__ = lambda self : None;
TrapezoidIntegralMidPoint_swigregister = _QuantLib.TrapezoidIntegralMidPoint_swigregister
TrapezoidIntegralMidPoint_swigregister(TrapezoidIntegralMidPoint)

class SimpsonIntegral(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SimpsonIntegral(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.SimpsonIntegral___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_SimpsonIntegral
    __del__ = lambda self : None;
SimpsonIntegral_swigregister = _QuantLib.SimpsonIntegral_swigregister
SimpsonIntegral_swigregister(SimpsonIntegral)

class GaussKronrodAdaptive(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussKronrodAdaptive(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.GaussKronrodAdaptive___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodAdaptive
    __del__ = lambda self : None;
GaussKronrodAdaptive_swigregister = _QuantLib.GaussKronrodAdaptive_swigregister
GaussKronrodAdaptive_swigregister(GaussKronrodAdaptive)

class GaussKronrodNonAdaptive(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussKronrodNonAdaptive(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.GaussKronrodNonAdaptive___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodNonAdaptive
    __del__ = lambda self : None;
GaussKronrodNonAdaptive_swigregister = _QuantLib.GaussKronrodNonAdaptive_swigregister
GaussKronrodNonAdaptive_swigregister(GaussKronrodNonAdaptive)

class SampleNumber(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def value(self): return _QuantLib.SampleNumber_value(self)
    def weight(self): return _QuantLib.SampleNumber_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleNumber
    __del__ = lambda self : None;
SampleNumber_swigregister = _QuantLib.SampleNumber_swigregister
SampleNumber_swigregister(SampleNumber)

class SampleArray(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def value(self): return _QuantLib.SampleArray_value(self)
    def weight(self): return _QuantLib.SampleArray_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleArray
    __del__ = lambda self : None;
SampleArray_swigregister = _QuantLib.SampleArray_swigregister
SampleArray_swigregister(SampleArray)

class SampleRealVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def value(self): return _QuantLib.SampleRealVector_value(self)
    def weight(self): return _QuantLib.SampleRealVector_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleRealVector
    __del__ = lambda self : None;
SampleRealVector_swigregister = _QuantLib.SampleRealVector_swigregister
SampleRealVector_swigregister(SampleRealVector)

class LecuyerUniformRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, seed = 0): 
        this = _QuantLib.new_LecuyerUniformRng(seed)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.LecuyerUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRng
    __del__ = lambda self : None;
LecuyerUniformRng_swigregister = _QuantLib.LecuyerUniformRng_swigregister
LecuyerUniformRng_swigregister(LecuyerUniformRng)

class KnuthUniformRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRng
    __del__ = lambda self : None;
KnuthUniformRng_swigregister = _QuantLib.KnuthUniformRng_swigregister
KnuthUniformRng_swigregister(KnuthUniformRng)

class MersenneTwisterUniformRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRng
    __del__ = lambda self : None;
MersenneTwisterUniformRng_swigregister = _QuantLib.MersenneTwisterUniformRng_swigregister
MersenneTwisterUniformRng_swigregister(MersenneTwisterUniformRng)

class UniformRandomGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, seed = 0): 
        this = _QuantLib.new_UniformRandomGenerator(seed)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.UniformRandomGenerator_next(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomGenerator
    __del__ = lambda self : None;
UniformRandomGenerator_swigregister = _QuantLib.UniformRandomGenerator_swigregister
UniformRandomGenerator_swigregister(UniformRandomGenerator)

class CentralLimitLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CentralLimitLecuyerGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.CentralLimitLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitLecuyerGaussianRng
    __del__ = lambda self : None;
CentralLimitLecuyerGaussianRng_swigregister = _QuantLib.CentralLimitLecuyerGaussianRng_swigregister
CentralLimitLecuyerGaussianRng_swigregister(CentralLimitLecuyerGaussianRng)

class CentralLimitKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CentralLimitKnuthGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.CentralLimitKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitKnuthGaussianRng
    __del__ = lambda self : None;
CentralLimitKnuthGaussianRng_swigregister = _QuantLib.CentralLimitKnuthGaussianRng_swigregister
CentralLimitKnuthGaussianRng_swigregister(CentralLimitKnuthGaussianRng)

class CentralLimitMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CentralLimitMersenneTwisterGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.CentralLimitMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitMersenneTwisterGaussianRng
    __del__ = lambda self : None;
CentralLimitMersenneTwisterGaussianRng_swigregister = _QuantLib.CentralLimitMersenneTwisterGaussianRng_swigregister
CentralLimitMersenneTwisterGaussianRng_swigregister(CentralLimitMersenneTwisterGaussianRng)

class BoxMullerLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BoxMullerLecuyerGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.BoxMullerLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerLecuyerGaussianRng
    __del__ = lambda self : None;
BoxMullerLecuyerGaussianRng_swigregister = _QuantLib.BoxMullerLecuyerGaussianRng_swigregister
BoxMullerLecuyerGaussianRng_swigregister(BoxMullerLecuyerGaussianRng)

class BoxMullerKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BoxMullerKnuthGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.BoxMullerKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerKnuthGaussianRng
    __del__ = lambda self : None;
BoxMullerKnuthGaussianRng_swigregister = _QuantLib.BoxMullerKnuthGaussianRng_swigregister
BoxMullerKnuthGaussianRng_swigregister(BoxMullerKnuthGaussianRng)

class BoxMullerMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BoxMullerMersenneTwisterGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.BoxMullerMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerMersenneTwisterGaussianRng
    __del__ = lambda self : None;
BoxMullerMersenneTwisterGaussianRng_swigregister = _QuantLib.BoxMullerMersenneTwisterGaussianRng_swigregister
BoxMullerMersenneTwisterGaussianRng_swigregister(BoxMullerMersenneTwisterGaussianRng)

class MoroInvCumulativeLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeLecuyerGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.MoroInvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRng
    __del__ = lambda self : None;
MoroInvCumulativeLecuyerGaussianRng_swigregister = _QuantLib.MoroInvCumulativeLecuyerGaussianRng_swigregister
MoroInvCumulativeLecuyerGaussianRng_swigregister(MoroInvCumulativeLecuyerGaussianRng)

class MoroInvCumulativeKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeKnuthGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.MoroInvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRng
    __del__ = lambda self : None;
MoroInvCumulativeKnuthGaussianRng_swigregister = _QuantLib.MoroInvCumulativeKnuthGaussianRng_swigregister
MoroInvCumulativeKnuthGaussianRng_swigregister(MoroInvCumulativeKnuthGaussianRng)

class MoroInvCumulativeMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRng
    __del__ = lambda self : None;
MoroInvCumulativeMersenneTwisterGaussianRng_swigregister = _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_swigregister
MoroInvCumulativeMersenneTwisterGaussianRng_swigregister(MoroInvCumulativeMersenneTwisterGaussianRng)

class InvCumulativeLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeLecuyerGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.InvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRng
    __del__ = lambda self : None;
InvCumulativeLecuyerGaussianRng_swigregister = _QuantLib.InvCumulativeLecuyerGaussianRng_swigregister
InvCumulativeLecuyerGaussianRng_swigregister(InvCumulativeLecuyerGaussianRng)

class InvCumulativeKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeKnuthGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.InvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRng
    __del__ = lambda self : None;
InvCumulativeKnuthGaussianRng_swigregister = _QuantLib.InvCumulativeKnuthGaussianRng_swigregister
InvCumulativeKnuthGaussianRng_swigregister(InvCumulativeKnuthGaussianRng)

class InvCumulativeMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeMersenneTwisterGaussianRng(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.InvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRng
    __del__ = lambda self : None;
InvCumulativeMersenneTwisterGaussianRng_swigregister = _QuantLib.InvCumulativeMersenneTwisterGaussianRng_swigregister
InvCumulativeMersenneTwisterGaussianRng_swigregister(InvCumulativeMersenneTwisterGaussianRng)

class GaussianRandomGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussianRandomGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.GaussianRandomGenerator_next(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomGenerator
    __del__ = lambda self : None;
GaussianRandomGenerator_swigregister = _QuantLib.GaussianRandomGenerator_swigregister
GaussianRandomGenerator_swigregister(GaussianRandomGenerator)

class HaltonRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_HaltonRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.HaltonRsg_nextSequence(self)
    def dimension(self): return _QuantLib.HaltonRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_HaltonRsg
    __del__ = lambda self : None;
HaltonRsg_swigregister = _QuantLib.HaltonRsg_swigregister
HaltonRsg_swigregister(HaltonRsg)

class SobolRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SobolRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.SobolRsg_nextSequence(self)
    def dimension(self): return _QuantLib.SobolRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_SobolRsg
    __del__ = lambda self : None;
SobolRsg_swigregister = _QuantLib.SobolRsg_swigregister
SobolRsg_swigregister(SobolRsg)

class LecuyerUniformRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_LecuyerUniformRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.LecuyerUniformRsg_nextSequence(self)
    def dimension(self): return _QuantLib.LecuyerUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRsg
    __del__ = lambda self : None;
LecuyerUniformRsg_swigregister = _QuantLib.LecuyerUniformRsg_swigregister
LecuyerUniformRsg_swigregister(LecuyerUniformRsg)

class KnuthUniformRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_KnuthUniformRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.KnuthUniformRsg_nextSequence(self)
    def dimension(self): return _QuantLib.KnuthUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRsg
    __del__ = lambda self : None;
KnuthUniformRsg_swigregister = _QuantLib.KnuthUniformRsg_swigregister
KnuthUniformRsg_swigregister(KnuthUniformRsg)

class MersenneTwisterUniformRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MersenneTwisterUniformRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.MersenneTwisterUniformRsg_nextSequence(self)
    def dimension(self): return _QuantLib.MersenneTwisterUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRsg
    __del__ = lambda self : None;
MersenneTwisterUniformRsg_swigregister = _QuantLib.MersenneTwisterUniformRsg_swigregister
MersenneTwisterUniformRsg_swigregister(MersenneTwisterUniformRsg)

class UniformRandomSequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_UniformRandomSequenceGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.UniformRandomSequenceGenerator_nextSequence(self)
    def dimension(self): return _QuantLib.UniformRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomSequenceGenerator
    __del__ = lambda self : None;
UniformRandomSequenceGenerator_swigregister = _QuantLib.UniformRandomSequenceGenerator_swigregister
UniformRandomSequenceGenerator_swigregister(UniformRandomSequenceGenerator)

class UniformLowDiscrepancySequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_UniformLowDiscrepancySequenceGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.UniformLowDiscrepancySequenceGenerator_nextSequence(self)
    def dimension(self): return _QuantLib.UniformLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformLowDiscrepancySequenceGenerator
    __del__ = lambda self : None;
UniformLowDiscrepancySequenceGenerator_swigregister = _QuantLib.UniformLowDiscrepancySequenceGenerator_swigregister
UniformLowDiscrepancySequenceGenerator_swigregister(UniformLowDiscrepancySequenceGenerator)

class MoroInvCumulativeLecuyerGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeLecuyerGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRsg
    __del__ = lambda self : None;
MoroInvCumulativeLecuyerGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_swigregister
MoroInvCumulativeLecuyerGaussianRsg_swigregister(MoroInvCumulativeLecuyerGaussianRsg)

class MoroInvCumulativeKnuthGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeKnuthGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRsg
    __del__ = lambda self : None;
MoroInvCumulativeKnuthGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeKnuthGaussianRsg_swigregister
MoroInvCumulativeKnuthGaussianRsg_swigregister(MoroInvCumulativeKnuthGaussianRsg)

class MoroInvCumulativeMersenneTwisterGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRsg
    __del__ = lambda self : None;
MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister
MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister(MoroInvCumulativeMersenneTwisterGaussianRsg)

class MoroInvCumulativeHaltonGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MoroInvCumulativeHaltonGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeHaltonGaussianRsg
    __del__ = lambda self : None;
MoroInvCumulativeHaltonGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeHaltonGaussianRsg_swigregister
MoroInvCumulativeHaltonGaussianRsg_swigregister(MoroInvCumulativeHaltonGaussianRsg)

class InvCumulativeLecuyerGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeLecuyerGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.InvCumulativeLecuyerGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.InvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRsg
    __del__ = lambda self : None;
InvCumulativeLecuyerGaussianRsg_swigregister = _QuantLib.InvCumulativeLecuyerGaussianRsg_swigregister
InvCumulativeLecuyerGaussianRsg_swigregister(InvCumulativeLecuyerGaussianRsg)

class InvCumulativeKnuthGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeKnuthGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.InvCumulativeKnuthGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.InvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRsg
    __del__ = lambda self : None;
InvCumulativeKnuthGaussianRsg_swigregister = _QuantLib.InvCumulativeKnuthGaussianRsg_swigregister
InvCumulativeKnuthGaussianRsg_swigregister(InvCumulativeKnuthGaussianRsg)

class InvCumulativeMersenneTwisterGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeMersenneTwisterGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRsg
    __del__ = lambda self : None;
InvCumulativeMersenneTwisterGaussianRsg_swigregister = _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_swigregister
InvCumulativeMersenneTwisterGaussianRsg_swigregister(InvCumulativeMersenneTwisterGaussianRsg)

class InvCumulativeHaltonGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_InvCumulativeHaltonGaussianRsg(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.InvCumulativeHaltonGaussianRsg_nextSequence(self)
    def dimension(self): return _QuantLib.InvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeHaltonGaussianRsg
    __del__ = lambda self : None;
InvCumulativeHaltonGaussianRsg_swigregister = _QuantLib.InvCumulativeHaltonGaussianRsg_swigregister
InvCumulativeHaltonGaussianRsg_swigregister(InvCumulativeHaltonGaussianRsg)

class GaussianRandomSequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussianRandomSequenceGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.GaussianRandomSequenceGenerator_nextSequence(self)
    def dimension(self): return _QuantLib.GaussianRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomSequenceGenerator
    __del__ = lambda self : None;
GaussianRandomSequenceGenerator_swigregister = _QuantLib.GaussianRandomSequenceGenerator_swigregister
GaussianRandomSequenceGenerator_swigregister(GaussianRandomSequenceGenerator)

class GaussianLowDiscrepancySequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussianLowDiscrepancySequenceGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def nextSequence(self): return _QuantLib.GaussianLowDiscrepancySequenceGenerator_nextSequence(self)
    def dimension(self): return _QuantLib.GaussianLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianLowDiscrepancySequenceGenerator
    __del__ = lambda self : None;
GaussianLowDiscrepancySequenceGenerator_swigregister = _QuantLib.GaussianLowDiscrepancySequenceGenerator_swigregister
GaussianLowDiscrepancySequenceGenerator_swigregister(GaussianLowDiscrepancySequenceGenerator)


def getCovariance(*args):
  return _QuantLib.getCovariance(*args)
getCovariance = _QuantLib.getCovariance
class Path(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __len__(self): return _QuantLib.Path___len__(self)
    def value(self, *args): return _QuantLib.Path_value(self, *args)
    def front(self): return _QuantLib.Path_front(self)
    def back(self): return _QuantLib.Path_back(self)
    def time(self, *args): return _QuantLib.Path_time(self, *args)
    def __getitem__(self, *args): return _QuantLib.Path___getitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Path
    __del__ = lambda self : None;
Path_swigregister = _QuantLib.Path_swigregister
Path_swigregister(Path)

class SamplePath(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def value(self): return _QuantLib.SamplePath_value(self)
    def weight(self): return _QuantLib.SamplePath_weight(self)
    __swig_destroy__ = _QuantLib.delete_SamplePath
    __del__ = lambda self : None;
SamplePath_swigregister = _QuantLib.SamplePath_swigregister
SamplePath_swigregister(SamplePath)

class GaussianPathGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussianPathGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.GaussianPathGenerator_next(self)
    def antithetic(self): return _QuantLib.GaussianPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianPathGenerator
    __del__ = lambda self : None;
GaussianPathGenerator_swigregister = _QuantLib.GaussianPathGenerator_swigregister
GaussianPathGenerator_swigregister(GaussianPathGenerator)

class GaussianSobolPathGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussianSobolPathGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.GaussianSobolPathGenerator_next(self)
    def antithetic(self): return _QuantLib.GaussianSobolPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianSobolPathGenerator
    __del__ = lambda self : None;
GaussianSobolPathGenerator_swigregister = _QuantLib.GaussianSobolPathGenerator_swigregister
GaussianSobolPathGenerator_swigregister(GaussianSobolPathGenerator)

class MultiPath(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __len__(self): return _QuantLib.MultiPath___len__(self)
    def assetNumber(self): return _QuantLib.MultiPath_assetNumber(self)
    def __getitem__(self, *args): return _QuantLib.MultiPath___getitem__(self, *args)
    __swig_destroy__ = _QuantLib.delete_MultiPath
    __del__ = lambda self : None;
MultiPath_swigregister = _QuantLib.MultiPath_swigregister
MultiPath_swigregister(MultiPath)

class SampleMultiPath(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def value(self): return _QuantLib.SampleMultiPath_value(self)
    def weight(self): return _QuantLib.SampleMultiPath_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleMultiPath
    __del__ = lambda self : None;
SampleMultiPath_swigregister = _QuantLib.SampleMultiPath_swigregister
SampleMultiPath_swigregister(SampleMultiPath)

class GaussianMultiPathGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GaussianMultiPathGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    def next(self): return _QuantLib.GaussianMultiPathGenerator_next(self)
    __swig_destroy__ = _QuantLib.delete_GaussianMultiPathGenerator
    __del__ = lambda self : None;
GaussianMultiPathGenerator_swigregister = _QuantLib.GaussianMultiPathGenerator_swigregister
GaussianMultiPathGenerator_swigregister(GaussianMultiPathGenerator)

class BoundaryCondition(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.BoundaryCondition___deref__(self)
    def __nonzero__(self): return _QuantLib.BoundaryCondition___nonzero__(self)
    NoSide = _QuantLib.BoundaryCondition_NoSide
    Upper = _QuantLib.BoundaryCondition_Upper
    Lower = _QuantLib.BoundaryCondition_Lower
    def __init__(self): 
        this = _QuantLib.new_BoundaryCondition()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BoundaryCondition
    __del__ = lambda self : None;
BoundaryCondition_swigregister = _QuantLib.BoundaryCondition_swigregister
BoundaryCondition_swigregister(BoundaryCondition)

class NeumannBC(BoundaryCondition):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_NeumannBC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NeumannBC
    __del__ = lambda self : None;
NeumannBC_swigregister = _QuantLib.NeumannBC_swigregister
NeumannBC_swigregister(NeumannBC)

class DirichletBC(BoundaryCondition):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DirichletBC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DirichletBC
    __del__ = lambda self : None;
DirichletBC_swigregister = _QuantLib.DirichletBC_swigregister
DirichletBC_swigregister(DirichletBC)

class TridiagonalOperator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TridiagonalOperator(*args)
        try: self.this.append(this)
        except: self.this = this
    def solveFor(self, *args): return _QuantLib.TridiagonalOperator_solveFor(self, *args)
    def applyTo(self, *args): return _QuantLib.TridiagonalOperator_applyTo(self, *args)
    def size(self): return _QuantLib.TridiagonalOperator_size(self)
    def setFirstRow(self, *args): return _QuantLib.TridiagonalOperator_setFirstRow(self, *args)
    def setMidRow(self, *args): return _QuantLib.TridiagonalOperator_setMidRow(self, *args)
    def setMidRows(self, *args): return _QuantLib.TridiagonalOperator_setMidRows(self, *args)
    def setLastRow(self, *args): return _QuantLib.TridiagonalOperator_setLastRow(self, *args)
    identity = staticmethod(_QuantLib.TridiagonalOperator_identity)
    def __add__(self, *args): return _QuantLib.TridiagonalOperator___add__(self, *args)
    def __sub__(self, *args): return _QuantLib.TridiagonalOperator___sub__(self, *args)
    def __mul__(self, *args): return _QuantLib.TridiagonalOperator___mul__(self, *args)
    def __div__(self, *args): return _QuantLib.TridiagonalOperator___div__(self, *args)
    def __iadd__(self, *args): return _QuantLib.TridiagonalOperator___iadd__(self, *args)
    def __isub__(self, *args): return _QuantLib.TridiagonalOperator___isub__(self, *args)
    def __imul__(self, *args): return _QuantLib.TridiagonalOperator___imul__(self, *args)
    def __rmul__(self, *args): return _QuantLib.TridiagonalOperator___rmul__(self, *args)
    def __idiv__(self, *args): return _QuantLib.TridiagonalOperator___idiv__(self, *args)
    __swig_destroy__ = _QuantLib.delete_TridiagonalOperator
    __del__ = lambda self : None;
TridiagonalOperator_swigregister = _QuantLib.TridiagonalOperator_swigregister
TridiagonalOperator_swigregister(TridiagonalOperator)

def TridiagonalOperator_identity(*args):
  return _QuantLib.TridiagonalOperator_identity(*args)
TridiagonalOperator_identity = _QuantLib.TridiagonalOperator_identity

class DPlus(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DPlus(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DPlus
    __del__ = lambda self : None;
DPlus_swigregister = _QuantLib.DPlus_swigregister
DPlus_swigregister(DPlus)

class DMinus(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DMinus(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DMinus
    __del__ = lambda self : None;
DMinus_swigregister = _QuantLib.DMinus_swigregister
DMinus_swigregister(DMinus)

class DZero(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DZero(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DZero
    __del__ = lambda self : None;
DZero_swigregister = _QuantLib.DZero_swigregister
DZero_swigregister(DZero)

class DPlusDMinus(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DPlusDMinus(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DPlusDMinus
    __del__ = lambda self : None;
DPlusDMinus_swigregister = _QuantLib.DPlusDMinus_swigregister
DPlusDMinus_swigregister(DPlusDMinus)

class Brent(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.Brent_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.Brent_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.Brent_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.Brent_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Brent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Brent
    __del__ = lambda self : None;
Brent_swigregister = _QuantLib.Brent_swigregister
Brent_swigregister(Brent)

class Bisection(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.Bisection_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.Bisection_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.Bisection_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.Bisection_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Bisection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Bisection
    __del__ = lambda self : None;
Bisection_swigregister = _QuantLib.Bisection_swigregister
Bisection_swigregister(Bisection)

class FalsePosition(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.FalsePosition_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.FalsePosition_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.FalsePosition_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.FalsePosition_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_FalsePosition()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FalsePosition
    __del__ = lambda self : None;
FalsePosition_swigregister = _QuantLib.FalsePosition_swigregister
FalsePosition_swigregister(FalsePosition)

class Ridder(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.Ridder_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.Ridder_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.Ridder_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.Ridder_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Ridder()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Ridder
    __del__ = lambda self : None;
Ridder_swigregister = _QuantLib.Ridder_swigregister
Ridder_swigregister(Ridder)

class Secant(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.Secant_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.Secant_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.Secant_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.Secant_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Secant()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Secant
    __del__ = lambda self : None;
Secant_swigregister = _QuantLib.Secant_swigregister
Secant_swigregister(Secant)

class Newton(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.Newton_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.Newton_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.Newton_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.Newton_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Newton()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Newton
    __del__ = lambda self : None;
Newton_swigregister = _QuantLib.Newton_swigregister
Newton_swigregister(Newton)

class NewtonSafe(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setMaxEvaluations(self, *args): return _QuantLib.NewtonSafe_setMaxEvaluations(self, *args)
    def setLowerBound(self, *args): return _QuantLib.NewtonSafe_setLowerBound(self, *args)
    def setUpperBound(self, *args): return _QuantLib.NewtonSafe_setUpperBound(self, *args)
    def solve(self, *args): return _QuantLib.NewtonSafe_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_NewtonSafe()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NewtonSafe
    __del__ = lambda self : None;
NewtonSafe_swigregister = _QuantLib.NewtonSafe_swigregister
NewtonSafe_swigregister(NewtonSafe)

class Constraint(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_Constraint
    __del__ = lambda self : None;
Constraint_swigregister = _QuantLib.Constraint_swigregister
Constraint_swigregister(Constraint)

class BoundaryConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BoundaryConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BoundaryConstraint
    __del__ = lambda self : None;
BoundaryConstraint_swigregister = _QuantLib.BoundaryConstraint_swigregister
BoundaryConstraint_swigregister(BoundaryConstraint)

class NoConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_NoConstraint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_NoConstraint
    __del__ = lambda self : None;
NoConstraint_swigregister = _QuantLib.NoConstraint_swigregister
NoConstraint_swigregister(NoConstraint)

class PositiveConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_PositiveConstraint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_PositiveConstraint
    __del__ = lambda self : None;
PositiveConstraint_swigregister = _QuantLib.PositiveConstraint_swigregister
PositiveConstraint_swigregister(PositiveConstraint)

class EndCriteria(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NoCriteria = _QuantLib.EndCriteria_NoCriteria
    MaxIterations = _QuantLib.EndCriteria_MaxIterations
    StationaryPoint = _QuantLib.EndCriteria_StationaryPoint
    StationaryFunctionValue = _QuantLib.EndCriteria_StationaryFunctionValue
    StationaryFunctionAccuracy = _QuantLib.EndCriteria_StationaryFunctionAccuracy
    ZeroGradientNorm = _QuantLib.EndCriteria_ZeroGradientNorm
    Unknown = _QuantLib.EndCriteria_Unknown
    def __init__(self, *args): 
        this = _QuantLib.new_EndCriteria(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args): return _QuantLib.EndCriteria___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_EndCriteria
    __del__ = lambda self : None;
EndCriteria_swigregister = _QuantLib.EndCriteria_swigregister
EndCriteria_swigregister(EndCriteria)

class OptimizationMethod(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_OptimizationMethod
    __del__ = lambda self : None;
OptimizationMethod_swigregister = _QuantLib.OptimizationMethod_swigregister
OptimizationMethod_swigregister(OptimizationMethod)

class ConjugateGradient(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ConjugateGradient()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ConjugateGradient
    __del__ = lambda self : None;
ConjugateGradient_swigregister = _QuantLib.ConjugateGradient_swigregister
ConjugateGradient_swigregister(ConjugateGradient)

class Simplex(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Simplex(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Simplex
    __del__ = lambda self : None;
Simplex_swigregister = _QuantLib.Simplex_swigregister
Simplex_swigregister(Simplex)

class SteepestDescent(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_SteepestDescent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SteepestDescent
    __del__ = lambda self : None;
SteepestDescent_swigregister = _QuantLib.SteepestDescent_swigregister
SteepestDescent_swigregister(SteepestDescent)

class BFGS(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_BFGS()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BFGS
    __del__ = lambda self : None;
BFGS_swigregister = _QuantLib.BFGS_swigregister
BFGS_swigregister(BFGS)

class Optimizer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def solve(self, *args): return _QuantLib.Optimizer_solve(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Optimizer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Optimizer
    __del__ = lambda self : None;
Optimizer_swigregister = _QuantLib.Optimizer_swigregister
Optimizer_swigregister(Optimizer)

class RateHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.RateHelper___deref__(self)
    def __nonzero__(self): return _QuantLib.RateHelper___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_RateHelper()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_RateHelper
    __del__ = lambda self : None;
RateHelper_swigregister = _QuantLib.RateHelper_swigregister
RateHelper_swigregister(RateHelper)

class DepositRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DepositRateHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DepositRateHelper
    __del__ = lambda self : None;
DepositRateHelper_swigregister = _QuantLib.DepositRateHelper_swigregister
DepositRateHelper_swigregister(DepositRateHelper)

class FraRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FraRateHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FraRateHelper
    __del__ = lambda self : None;
FraRateHelper_swigregister = _QuantLib.FraRateHelper_swigregister
FraRateHelper_swigregister(FraRateHelper)

class FuturesRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FuturesRateHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_FuturesRateHelper
    __del__ = lambda self : None;
FuturesRateHelper_swigregister = _QuantLib.FuturesRateHelper_swigregister
FuturesRateHelper_swigregister(FuturesRateHelper)

class SwapRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SwapRateHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_SwapRateHelper
    __del__ = lambda self : None;
SwapRateHelper_swigregister = _QuantLib.SwapRateHelper_swigregister
SwapRateHelper_swigregister(SwapRateHelper)

class FixedRateBondHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_FixedRateBondHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    def bond(self): return _QuantLib.FixedRateBondHelper_bond(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBondHelper
    __del__ = lambda self : None;
FixedRateBondHelper_swigregister = _QuantLib.FixedRateBondHelper_swigregister
FixedRateBondHelper_swigregister(FixedRateBondHelper)

class RateHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.RateHelperVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.RateHelperVector___nonzero__(self)
    def __bool__(self): return _QuantLib.RateHelperVector___bool__(self)
    def __len__(self): return _QuantLib.RateHelperVector___len__(self)
    def pop(self): return _QuantLib.RateHelperVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.RateHelperVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.RateHelperVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.RateHelperVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.RateHelperVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.RateHelperVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.RateHelperVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.RateHelperVector_append(self, *args)
    def empty(self): return _QuantLib.RateHelperVector_empty(self)
    def size(self): return _QuantLib.RateHelperVector_size(self)
    def clear(self): return _QuantLib.RateHelperVector_clear(self)
    def swap(self, *args): return _QuantLib.RateHelperVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.RateHelperVector_get_allocator(self)
    def begin(self): return _QuantLib.RateHelperVector_begin(self)
    def end(self): return _QuantLib.RateHelperVector_end(self)
    def rbegin(self): return _QuantLib.RateHelperVector_rbegin(self)
    def rend(self): return _QuantLib.RateHelperVector_rend(self)
    def pop_back(self): return _QuantLib.RateHelperVector_pop_back(self)
    def erase(self, *args): return _QuantLib.RateHelperVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_RateHelperVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.RateHelperVector_push_back(self, *args)
    def front(self): return _QuantLib.RateHelperVector_front(self)
    def back(self): return _QuantLib.RateHelperVector_back(self)
    def assign(self, *args): return _QuantLib.RateHelperVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.RateHelperVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.RateHelperVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.RateHelperVector_reserve(self, *args)
    def capacity(self): return _QuantLib.RateHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RateHelperVector
    __del__ = lambda self : None;
RateHelperVector_swigregister = _QuantLib.RateHelperVector_swigregister
RateHelperVector_swigregister(RateHelperVector)

class Discount(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_Discount()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Discount
    __del__ = lambda self : None;
Discount_swigregister = _QuantLib.Discount_swigregister
Discount_swigregister(Discount)

class ZeroYield(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ZeroYield()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroYield
    __del__ = lambda self : None;
ZeroYield_swigregister = _QuantLib.ZeroYield_swigregister
ZeroYield_swigregister(ZeroYield)

class ForwardRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_ForwardRate()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardRate
    __del__ = lambda self : None;
ForwardRate_swigregister = _QuantLib.ForwardRate_swigregister
ForwardRate_swigregister(ForwardRate)

class PiecewiseFlatForward(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_PiecewiseFlatForward(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.PiecewiseFlatForward_dates(self)
    def times(self): return _QuantLib.PiecewiseFlatForward_times(self)
    def nodes(self): return _QuantLib.PiecewiseFlatForward_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseFlatForward
    __del__ = lambda self : None;
PiecewiseFlatForward_swigregister = _QuantLib.PiecewiseFlatForward_swigregister
PiecewiseFlatForward_swigregister(PiecewiseFlatForward)

class SampledCurve(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SampledCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    def grid(self): return _QuantLib.SampledCurve_grid(self)
    def values(self): return _QuantLib.SampledCurve_values(self)
    def gridValue(self, *args): return _QuantLib.SampledCurve_gridValue(self, *args)
    def value(self, *args): return _QuantLib.SampledCurve_value(self, *args)
    def size(self): return _QuantLib.SampledCurve_size(self)
    def empty(self): return _QuantLib.SampledCurve_empty(self)
    def setGrid(self, *args): return _QuantLib.SampledCurve_setGrid(self, *args)
    def setValues(self, *args): return _QuantLib.SampledCurve_setValues(self, *args)
    def swap(self, *args): return _QuantLib.SampledCurve_swap(self, *args)
    def setLogGrid(self, *args): return _QuantLib.SampledCurve_setLogGrid(self, *args)
    def regridLogGrid(self, *args): return _QuantLib.SampledCurve_regridLogGrid(self, *args)
    def shiftGrid(self, *args): return _QuantLib.SampledCurve_shiftGrid(self, *args)
    def scaleGrid(self, *args): return _QuantLib.SampledCurve_scaleGrid(self, *args)
    def regrid(self, *args): return _QuantLib.SampledCurve_regrid(self, *args)
    __swig_destroy__ = _QuantLib.delete_SampledCurve
    __del__ = lambda self : None;
SampledCurve_swigregister = _QuantLib.SampledCurve_swigregister
SampledCurve_swigregister(SampledCurve)

class Settings(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    instance = staticmethod(_QuantLib.Settings_instance)
    def getEvaluationDate(self): return _QuantLib.Settings_getEvaluationDate(self)
    def setEvaluationDate(self, *args): return _QuantLib.Settings_setEvaluationDate(self, *args)
    def includeReferenceDateCashFlows(self, *args): return _QuantLib.Settings_includeReferenceDateCashFlows(self, *args)
    def includeTodaysCashFlows(self, *args): return _QuantLib.Settings_includeTodaysCashFlows(self, *args)
    evaluationDate = property(getEvaluationDate,setEvaluationDate,None)
    includeReferenceDateCashFlows = property(None,includeReferenceDateCashFlows,None)
    includeTodaysCashFlows = property(None,includeTodaysCashFlows,None)

    __swig_destroy__ = _QuantLib.delete_Settings
    __del__ = lambda self : None;
Settings_swigregister = _QuantLib.Settings_swigregister
Settings_swigregister(Settings)

def Settings_instance():
  return _QuantLib.Settings_instance()
Settings_instance = _QuantLib.Settings_instance

class CalibrationHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.CalibrationHelper___deref__(self)
    def __nonzero__(self): return _QuantLib.CalibrationHelper___nonzero__(self)
    RelativePriceError = _QuantLib.CalibrationHelper_RelativePriceError
    PriceError = _QuantLib.CalibrationHelper_PriceError
    ImpliedVolError = _QuantLib.CalibrationHelper_ImpliedVolError
    def __init__(self): 
        this = _QuantLib.new_CalibrationHelper()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CalibrationHelper
    __del__ = lambda self : None;
    def setPricingEngine(self, *args): return _QuantLib.CalibrationHelper_setPricingEngine(self, *args)
    def marketValue(self): return _QuantLib.CalibrationHelper_marketValue(self)
    def modelValue(self): return _QuantLib.CalibrationHelper_modelValue(self)
    def impliedVolatility(self, *args): return _QuantLib.CalibrationHelper_impliedVolatility(self, *args)
    def blackPrice(self, *args): return _QuantLib.CalibrationHelper_blackPrice(self, *args)
CalibrationHelper_swigregister = _QuantLib.CalibrationHelper_swigregister
CalibrationHelper_swigregister(CalibrationHelper)

class SwaptionHelper(CalibrationHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SwaptionHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    def times(self): return _QuantLib.SwaptionHelper_times(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionHelper
    __del__ = lambda self : None;
SwaptionHelper_swigregister = _QuantLib.SwaptionHelper_swigregister
SwaptionHelper_swigregister(SwaptionHelper)

class CapHelper(CalibrationHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapHelper(*args)
        try: self.this.append(this)
        except: self.this = this
    def times(self): return _QuantLib.CapHelper_times(self)
    __swig_destroy__ = _QuantLib.delete_CapHelper
    __del__ = lambda self : None;
CapHelper_swigregister = _QuantLib.CapHelper_swigregister
CapHelper_swigregister(CapHelper)

class CalibrationHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self): return _QuantLib.CalibrationHelperVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _QuantLib.CalibrationHelperVector___nonzero__(self)
    def __bool__(self): return _QuantLib.CalibrationHelperVector___bool__(self)
    def __len__(self): return _QuantLib.CalibrationHelperVector___len__(self)
    def pop(self): return _QuantLib.CalibrationHelperVector_pop(self)
    def __getslice__(self, *args): return _QuantLib.CalibrationHelperVector___getslice__(self, *args)
    def __setslice__(self, *args): return _QuantLib.CalibrationHelperVector___setslice__(self, *args)
    def __delslice__(self, *args): return _QuantLib.CalibrationHelperVector___delslice__(self, *args)
    def __delitem__(self, *args): return _QuantLib.CalibrationHelperVector___delitem__(self, *args)
    def __getitem__(self, *args): return _QuantLib.CalibrationHelperVector___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.CalibrationHelperVector___setitem__(self, *args)
    def append(self, *args): return _QuantLib.CalibrationHelperVector_append(self, *args)
    def empty(self): return _QuantLib.CalibrationHelperVector_empty(self)
    def size(self): return _QuantLib.CalibrationHelperVector_size(self)
    def clear(self): return _QuantLib.CalibrationHelperVector_clear(self)
    def swap(self, *args): return _QuantLib.CalibrationHelperVector_swap(self, *args)
    def get_allocator(self): return _QuantLib.CalibrationHelperVector_get_allocator(self)
    def begin(self): return _QuantLib.CalibrationHelperVector_begin(self)
    def end(self): return _QuantLib.CalibrationHelperVector_end(self)
    def rbegin(self): return _QuantLib.CalibrationHelperVector_rbegin(self)
    def rend(self): return _QuantLib.CalibrationHelperVector_rend(self)
    def pop_back(self): return _QuantLib.CalibrationHelperVector_pop_back(self)
    def erase(self, *args): return _QuantLib.CalibrationHelperVector_erase(self, *args)
    def __init__(self, *args): 
        this = _QuantLib.new_CalibrationHelperVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _QuantLib.CalibrationHelperVector_push_back(self, *args)
    def front(self): return _QuantLib.CalibrationHelperVector_front(self)
    def back(self): return _QuantLib.CalibrationHelperVector_back(self)
    def assign(self, *args): return _QuantLib.CalibrationHelperVector_assign(self, *args)
    def resize(self, *args): return _QuantLib.CalibrationHelperVector_resize(self, *args)
    def insert(self, *args): return _QuantLib.CalibrationHelperVector_insert(self, *args)
    def reserve(self, *args): return _QuantLib.CalibrationHelperVector_reserve(self, *args)
    def capacity(self): return _QuantLib.CalibrationHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationHelperVector
    __del__ = lambda self : None;
CalibrationHelperVector_swigregister = _QuantLib.CalibrationHelperVector_swigregister
CalibrationHelperVector_swigregister(CalibrationHelperVector)

class ShortRateModel(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.ShortRateModel___deref__(self)
    def __nonzero__(self): return _QuantLib.ShortRateModel___nonzero__(self)
    def asObservable(self): return _QuantLib.ShortRateModel_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_ShortRateModel()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_ShortRateModel
    __del__ = lambda self : None;
    def params(self): return _QuantLib.ShortRateModel_params(self)
    def calibrate(self, *args): return _QuantLib.ShortRateModel_calibrate(self, *args)
ShortRateModel_swigregister = _QuantLib.ShortRateModel_swigregister
ShortRateModel_swigregister(ShortRateModel)

class ShortRateModelHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ShortRateModelHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.ShortRateModelHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.ShortRateModelHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.ShortRateModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_ShortRateModelHandle
    __del__ = lambda self : None;
    def params(self): return _QuantLib.ShortRateModelHandle_params(self)
    def calibrate(self, *args): return _QuantLib.ShortRateModelHandle_calibrate(self, *args)
ShortRateModelHandle_swigregister = _QuantLib.ShortRateModelHandle_swigregister
ShortRateModelHandle_swigregister(ShortRateModelHandle)

class RelinkableShortRateModelHandle(ShortRateModelHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableShortRateModelHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableShortRateModelHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableShortRateModelHandle
    __del__ = lambda self : None;
RelinkableShortRateModelHandle_swigregister = _QuantLib.RelinkableShortRateModelHandle_swigregister
RelinkableShortRateModelHandle_swigregister(RelinkableShortRateModelHandle)

class Vasicek(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, r0 = 0.05, a = 0.1, b = 0.05, sigma = 0.01, _lambda = 0.0): 
        this = _QuantLib.new_Vasicek(r0, a, b, sigma, _lambda)
        try: self.this.append(this)
        except: self.this = this
    def discount(self, *args): return _QuantLib.Vasicek_discount(self, *args)
    __swig_destroy__ = _QuantLib.delete_Vasicek
    __del__ = lambda self : None;
Vasicek_swigregister = _QuantLib.Vasicek_swigregister
Vasicek_swigregister(Vasicek)

class HullWhite(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_HullWhite(*args)
        try: self.this.append(this)
        except: self.this = this
    def discount(self, *args): return _QuantLib.HullWhite_discount(self, *args)
    __swig_destroy__ = _QuantLib.delete_HullWhite
    __del__ = lambda self : None;
HullWhite_swigregister = _QuantLib.HullWhite_swigregister
HullWhite_swigregister(HullWhite)

class BlackKarasinski(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackKarasinski(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackKarasinski
    __del__ = lambda self : None;
BlackKarasinski_swigregister = _QuantLib.BlackKarasinski_swigregister
BlackKarasinski_swigregister(BlackKarasinski)

class G2(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_G2(*args)
        try: self.this.append(this)
        except: self.this = this
    def discount(self, *args): return _QuantLib.G2_discount(self, *args)
    __swig_destroy__ = _QuantLib.delete_G2
    __del__ = lambda self : None;
G2_swigregister = _QuantLib.G2_swigregister
G2_swigregister(G2)

class JamshidianSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_JamshidianSwaptionEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_JamshidianSwaptionEngine
    __del__ = lambda self : None;
JamshidianSwaptionEngine_swigregister = _QuantLib.JamshidianSwaptionEngine_swigregister
JamshidianSwaptionEngine_swigregister(JamshidianSwaptionEngine)

class TreeSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TreeSwaptionEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TreeSwaptionEngine
    __del__ = lambda self : None;
TreeSwaptionEngine_swigregister = _QuantLib.TreeSwaptionEngine_swigregister
TreeSwaptionEngine_swigregister(TreeSwaptionEngine)

class AnalyticCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_AnalyticCapFloorEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticCapFloorEngine
    __del__ = lambda self : None;
AnalyticCapFloorEngine_swigregister = _QuantLib.AnalyticCapFloorEngine_swigregister
AnalyticCapFloorEngine_swigregister(AnalyticCapFloorEngine)

class TreeCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TreeCapFloorEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TreeCapFloorEngine
    __del__ = lambda self : None;
TreeCapFloorEngine_swigregister = _QuantLib.TreeCapFloorEngine_swigregister
TreeCapFloorEngine_swigregister(TreeCapFloorEngine)

class G2SwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_G2SwaptionEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_G2SwaptionEngine
    __del__ = lambda self : None;
G2SwaptionEngine_swigregister = _QuantLib.G2SwaptionEngine_swigregister
G2SwaptionEngine_swigregister(G2SwaptionEngine)

class Statistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def samples(self): return _QuantLib.Statistics_samples(self)
    def weightSum(self): return _QuantLib.Statistics_weightSum(self)
    def mean(self): return _QuantLib.Statistics_mean(self)
    def variance(self): return _QuantLib.Statistics_variance(self)
    def standardDeviation(self): return _QuantLib.Statistics_standardDeviation(self)
    def errorEstimate(self): return _QuantLib.Statistics_errorEstimate(self)
    def skewness(self): return _QuantLib.Statistics_skewness(self)
    def kurtosis(self): return _QuantLib.Statistics_kurtosis(self)
    def min(self): return _QuantLib.Statistics_min(self)
    def max(self): return _QuantLib.Statistics_max(self)
    def reset(self): return _QuantLib.Statistics_reset(self)
    def add(self, *args): return _QuantLib.Statistics_add(self, *args)
    def __init__(self): 
        this = _QuantLib.new_Statistics()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Statistics
    __del__ = lambda self : None;
Statistics_swigregister = _QuantLib.Statistics_swigregister
Statistics_swigregister(Statistics)

class RiskStatistics(Statistics):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def semiVariance(self): return _QuantLib.RiskStatistics_semiVariance(self)
    def semiDeviation(self): return _QuantLib.RiskStatistics_semiDeviation(self)
    def downsideVariance(self): return _QuantLib.RiskStatistics_downsideVariance(self)
    def downsideDeviation(self): return _QuantLib.RiskStatistics_downsideDeviation(self)
    def regret(self, *args): return _QuantLib.RiskStatistics_regret(self, *args)
    def potentialUpside(self, *args): return _QuantLib.RiskStatistics_potentialUpside(self, *args)
    def valueAtRisk(self, *args): return _QuantLib.RiskStatistics_valueAtRisk(self, *args)
    def expectedShortfall(self, *args): return _QuantLib.RiskStatistics_expectedShortfall(self, *args)
    def shortfall(self, *args): return _QuantLib.RiskStatistics_shortfall(self, *args)
    def averageShortfall(self, *args): return _QuantLib.RiskStatistics_averageShortfall(self, *args)
    def __init__(self): 
        this = _QuantLib.new_RiskStatistics()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_RiskStatistics
    __del__ = lambda self : None;
RiskStatistics_swigregister = _QuantLib.RiskStatistics_swigregister
RiskStatistics_swigregister(RiskStatistics)

class MultipleStatistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_MultipleStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self): return _QuantLib.MultipleStatistics_size(self)
    def samples(self): return _QuantLib.MultipleStatistics_samples(self)
    def weightSum(self): return _QuantLib.MultipleStatistics_weightSum(self)
    def mean(self): return _QuantLib.MultipleStatistics_mean(self)
    def variance(self): return _QuantLib.MultipleStatistics_variance(self)
    def standardDeviation(self): return _QuantLib.MultipleStatistics_standardDeviation(self)
    def errorEstimate(self): return _QuantLib.MultipleStatistics_errorEstimate(self)
    def skewness(self): return _QuantLib.MultipleStatistics_skewness(self)
    def kurtosis(self): return _QuantLib.MultipleStatistics_kurtosis(self)
    def min(self): return _QuantLib.MultipleStatistics_min(self)
    def max(self): return _QuantLib.MultipleStatistics_max(self)
    def covariance(self): return _QuantLib.MultipleStatistics_covariance(self)
    def correlation(self): return _QuantLib.MultipleStatistics_correlation(self)
    def reset(self): return _QuantLib.MultipleStatistics_reset(self)
    def add(self, *args): return _QuantLib.MultipleStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_MultipleStatistics
    __del__ = lambda self : None;
MultipleStatistics_swigregister = _QuantLib.MultipleStatistics_swigregister
MultipleStatistics_swigregister(MultipleStatistics)

class SequenceStatistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_SequenceStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self): return _QuantLib.SequenceStatistics_size(self)
    def samples(self): return _QuantLib.SequenceStatistics_samples(self)
    def weightSum(self): return _QuantLib.SequenceStatistics_weightSum(self)
    def mean(self): return _QuantLib.SequenceStatistics_mean(self)
    def variance(self): return _QuantLib.SequenceStatistics_variance(self)
    def standardDeviation(self): return _QuantLib.SequenceStatistics_standardDeviation(self)
    def errorEstimate(self): return _QuantLib.SequenceStatistics_errorEstimate(self)
    def skewness(self): return _QuantLib.SequenceStatistics_skewness(self)
    def kurtosis(self): return _QuantLib.SequenceStatistics_kurtosis(self)
    def min(self): return _QuantLib.SequenceStatistics_min(self)
    def max(self): return _QuantLib.SequenceStatistics_max(self)
    def covariance(self): return _QuantLib.SequenceStatistics_covariance(self)
    def correlation(self): return _QuantLib.SequenceStatistics_correlation(self)
    def reset(self): return _QuantLib.SequenceStatistics_reset(self)
    def add(self, *args): return _QuantLib.SequenceStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_SequenceStatistics
    __del__ = lambda self : None;
SequenceStatistics_swigregister = _QuantLib.SequenceStatistics_swigregister
SequenceStatistics_swigregister(SequenceStatistics)

class TimeBasket(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_TimeBasket(*args)
        try: self.this.append(this)
        except: self.this = this
    def __len__(self): return _QuantLib.TimeBasket___len__(self)
    def rebin(self, *args): return _QuantLib.TimeBasket_rebin(self, *args)
    def __getitem__(self, *args): return _QuantLib.TimeBasket___getitem__(self, *args)
    def __setitem__(self, *args): return _QuantLib.TimeBasket___setitem__(self, *args)
    def items(self): return _QuantLib.TimeBasket_items(self)
    def __contains__(self, *args): return _QuantLib.TimeBasket___contains__(self, *args)
    def __iter__(self): return _QuantLib.TimeBasket___iter__(self)
    __swig_destroy__ = _QuantLib.delete_TimeBasket
    __del__ = lambda self : None;
TimeBasket_swigregister = _QuantLib.TimeBasket_swigregister
TimeBasket_swigregister(TimeBasket)

class Swap(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Swap(*args)
        try: self.this.append(this)
        except: self.this = this
    def startDate(self): return _QuantLib.Swap_startDate(self)
    def maturityDate(self): return _QuantLib.Swap_maturityDate(self)
    __swig_destroy__ = _QuantLib.delete_Swap
    __del__ = lambda self : None;
Swap_swigregister = _QuantLib.Swap_swigregister
Swap_swigregister(Swap)

class VanillaSwap(Swap):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Receiver = _QuantLib.VanillaSwap_Receiver
    Payer = _QuantLib.VanillaSwap_Payer
    def __init__(self, *args): 
        this = _QuantLib.new_VanillaSwap(*args)
        try: self.this.append(this)
        except: self.this = this
    def fairRate(self): return _QuantLib.VanillaSwap_fairRate(self)
    def fairSpread(self): return _QuantLib.VanillaSwap_fairSpread(self)
    def fixedLegBPS(self): return _QuantLib.VanillaSwap_fixedLegBPS(self)
    def floatingLegBPS(self): return _QuantLib.VanillaSwap_floatingLegBPS(self)
    __swig_destroy__ = _QuantLib.delete_VanillaSwap
    __del__ = lambda self : None;
VanillaSwap_swigregister = _QuantLib.VanillaSwap_swigregister
VanillaSwap_swigregister(VanillaSwap)

class DiscountingSwapEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_DiscountingSwapEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_DiscountingSwapEngine
    __del__ = lambda self : None;
DiscountingSwapEngine_swigregister = _QuantLib.DiscountingSwapEngine_swigregister
DiscountingSwapEngine_swigregister(DiscountingSwapEngine)

class CapFloorTermVolatilityStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.CapFloorTermVolatilityStructure___deref__(self)
    def __nonzero__(self): return _QuantLib.CapFloorTermVolatilityStructure___nonzero__(self)
    def asObservable(self): return _QuantLib.CapFloorTermVolatilityStructure_asObservable(self)
    def __init__(self): 
        this = _QuantLib.new_CapFloorTermVolatilityStructure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructure
    __del__ = lambda self : None;
    def volatility(self, *args): return _QuantLib.CapFloorTermVolatilityStructure_volatility(self, *args)
    def enableExtrapolation(self): return _QuantLib.CapFloorTermVolatilityStructure_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.CapFloorTermVolatilityStructure_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.CapFloorTermVolatilityStructure_allowsExtrapolation(self)
CapFloorTermVolatilityStructure_swigregister = _QuantLib.CapFloorTermVolatilityStructure_swigregister
CapFloorTermVolatilityStructure_swigregister(CapFloorTermVolatilityStructure)

class CapFloorTermVolatilityStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapFloorTermVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self): return _QuantLib.CapFloorTermVolatilityStructureHandle___deref__(self)
    def __nonzero__(self): return _QuantLib.CapFloorTermVolatilityStructureHandle___nonzero__(self)
    def asObservable(self): return _QuantLib.CapFloorTermVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructureHandle
    __del__ = lambda self : None;
    def volatility(self, *args): return _QuantLib.CapFloorTermVolatilityStructureHandle_volatility(self, *args)
    def enableExtrapolation(self): return _QuantLib.CapFloorTermVolatilityStructureHandle_enableExtrapolation(self)
    def disableExtrapolation(self): return _QuantLib.CapFloorTermVolatilityStructureHandle_disableExtrapolation(self)
    def allowsExtrapolation(self): return _QuantLib.CapFloorTermVolatilityStructureHandle_allowsExtrapolation(self)
CapFloorTermVolatilityStructureHandle_swigregister = _QuantLib.CapFloorTermVolatilityStructureHandle_swigregister
CapFloorTermVolatilityStructureHandle_swigregister(CapFloorTermVolatilityStructureHandle)

class RelinkableCapFloorTermVolatilityStructureHandle(CapFloorTermVolatilityStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_RelinkableCapFloorTermVolatilityStructureHandle(*args)
        try: self.this.append(this)
        except: self.this = this
    def linkTo(self, *args): return _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_linkTo(self, *args)
    __swig_destroy__ = _QuantLib.delete_RelinkableCapFloorTermVolatilityStructureHandle
    __del__ = lambda self : None;
RelinkableCapFloorTermVolatilityStructureHandle_swigregister = _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_swigregister
RelinkableCapFloorTermVolatilityStructureHandle_swigregister(RelinkableCapFloorTermVolatilityStructureHandle)

class CapFloorTermVolCurve(CapFloorTermVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_CapFloorTermVolCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolCurve
    __del__ = lambda self : None;
CapFloorTermVolCurve_swigregister = _QuantLib.CapFloorTermVolCurve_swigregister
CapFloorTermVolCurve_swigregister(CapFloorTermVolCurve)

class Settlement(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Physical = _QuantLib.Settlement_Physical
    Cash = _QuantLib.Settlement_Cash
    def __init__(self): 
        this = _QuantLib.new_Settlement()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Settlement
    __del__ = lambda self : None;
Settlement_swigregister = _QuantLib.Settlement_swigregister
Settlement_swigregister(Settlement)

class Swaption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_Swaption(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Swaption
    __del__ = lambda self : None;
Swaption_swigregister = _QuantLib.Swaption_swigregister
Swaption_swigregister(Swaption)

class BlackSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_BlackSwaptionEngine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackSwaptionEngine
    __del__ = lambda self : None;
BlackSwaptionEngine_swigregister = _QuantLib.BlackSwaptionEngine_swigregister
BlackSwaptionEngine_swigregister(BlackSwaptionEngine)

class Surface(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __deref__(self): return _QuantLib.Surface___deref__(self)
    def __nonzero__(self): return _QuantLib.Surface___nonzero__(self)
    def __init__(self): 
        this = _QuantLib.new_Surface()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_Surface
    __del__ = lambda self : None;
    def __call__(self, *args): return _QuantLib.Surface___call__(self, *args)
    def domain(self): return _QuantLib.Surface_domain(self)
Surface_swigregister = _QuantLib.Surface_swigregister
Surface_swigregister(Surface)

class TestSurface(Surface):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        this = _QuantLib.new_TestSurface()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _QuantLib.delete_TestSurface
    __del__ = lambda self : None;
TestSurface_swigregister = _QuantLib.TestSurface_swigregister
TestSurface_swigregister(TestSurface)

class ConstantEstimator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ConstantEstimator(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.ConstantEstimator_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_ConstantEstimator
    __del__ = lambda self : None;
ConstantEstimator_swigregister = _QuantLib.ConstantEstimator_swigregister
ConstantEstimator_swigregister(ConstantEstimator)

class ParkinsonSigma(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ParkinsonSigma(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.ParkinsonSigma_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_ParkinsonSigma
    __del__ = lambda self : None;
ParkinsonSigma_swigregister = _QuantLib.ParkinsonSigma_swigregister
ParkinsonSigma_swigregister(ParkinsonSigma)

class GarmanKlassSigma1(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GarmanKlassSigma1(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.GarmanKlassSigma1_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma1
    __del__ = lambda self : None;
GarmanKlassSigma1_swigregister = _QuantLib.GarmanKlassSigma1_swigregister
GarmanKlassSigma1_swigregister(GarmanKlassSigma1)

class GarmanKlassSigma3(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GarmanKlassSigma3(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.GarmanKlassSigma3_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma3
    __del__ = lambda self : None;
GarmanKlassSigma3_swigregister = _QuantLib.GarmanKlassSigma3_swigregister
GarmanKlassSigma3_swigregister(GarmanKlassSigma3)

class GarmanKlassSigma4(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GarmanKlassSigma4(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.GarmanKlassSigma4_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma4
    __del__ = lambda self : None;
GarmanKlassSigma4_swigregister = _QuantLib.GarmanKlassSigma4_swigregister
GarmanKlassSigma4_swigregister(GarmanKlassSigma4)

class GarmanKlassSigma5(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GarmanKlassSigma5(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.GarmanKlassSigma5_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma5
    __del__ = lambda self : None;
GarmanKlassSigma5_swigregister = _QuantLib.GarmanKlassSigma5_swigregister
GarmanKlassSigma5_swigregister(GarmanKlassSigma5)

class GarmanKlassSigma6(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_GarmanKlassSigma6(*args)
        try: self.this.append(this)
        except: self.this = this
    def calculate(self, *args): return _QuantLib.GarmanKlassSigma6_calculate(self, *args)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma6
    __del__ = lambda self : None;
GarmanKlassSigma6_swigregister = _QuantLib.GarmanKlassSigma6_swigregister
GarmanKlassSigma6_swigregister(GarmanKlassSigma6)

class ZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _QuantLib.new_ZeroCurve(*args)
        try: self.this.append(this)
        except: self.this = this
    def dates(self): return _QuantLib.ZeroCurve_dates(self)
    def zeroRates(self): return _QuantLib.ZeroCurve_zeroRates(self)
    def nodes(self): return _QuantLib.ZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ZeroCurve
    __del__ = lambda self : None;
ZeroCurve_swigregister = _QuantLib.ZeroCurve_swigregister
ZeroCurve_swigregister(ZeroCurve)