# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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 as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _QuantLib
else:
    import _QuantLib

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = 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

    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, x):
        return _QuantLib.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _QuantLib.SwigPyIterator_equal(self, x)

    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, n):
        return _QuantLib.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _QuantLib.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _QuantLib.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _QuantLib.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _QuantLib.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _QuantLib.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _QuantLib.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _QuantLib:
_QuantLib.SwigPyIterator_swigregister(SwigPyIterator)
cvar = _QuantLib.cvar
__hexversion__ = cvar.__hexversion__
__version__ = cvar.__version__

SHARED_PTR_DISOWN = _QuantLib.SHARED_PTR_DISOWN
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
Hours = _QuantLib.Hours
Minutes = _QuantLib.Minutes
Seconds = _QuantLib.Seconds
Milliseconds = _QuantLib.Milliseconds
Microseconds = _QuantLib.Microseconds
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 = 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):
        _QuantLib.Period_swiginit(self, _QuantLib.new_Period(*args))

    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 __add__(self, p):
        return _QuantLib.Period___add__(self, p)

    def __sub__(self, p):
        return _QuantLib.Period___sub__(self, p)

    def __mul__(self, n):
        return _QuantLib.Period___mul__(self, n)

    def __rmul__(self, n):
        return _QuantLib.Period___rmul__(self, n)

    def __lt__(self, other):
        return _QuantLib.Period___lt__(self, other)

    def __gt__(self, other):
        return _QuantLib.Period___gt__(self, other)

    def __le__(self, other):
        return _QuantLib.Period___le__(self, other)

    def __ge__(self, other):
        return _QuantLib.Period___ge__(self, other)

    def __eq__(self, other):
        return _QuantLib.Period___eq__(self, other)

    def __cmp__(self, other):
        return _QuantLib.Period___cmp__(self, other)

    def __hash__(self):
        return hash(str(self))

    __swig_destroy__ = _QuantLib.delete_Period

# Register Period in _QuantLib:
_QuantLib.Period_swigregister(Period)

class PeriodVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.PeriodVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.PeriodVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.PeriodVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.PeriodVector_pop(self)

    def append(self, x):
        return _QuantLib.PeriodVector_append(self, x)

    def empty(self):
        return _QuantLib.PeriodVector_empty(self)

    def size(self):
        return _QuantLib.PeriodVector_size(self)

    def swap(self, v):
        return _QuantLib.PeriodVector_swap(self, v)

    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 clear(self):
        return _QuantLib.PeriodVector_clear(self)

    def get_allocator(self):
        return _QuantLib.PeriodVector_get_allocator(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):
        _QuantLib.PeriodVector_swiginit(self, _QuantLib.new_PeriodVector(*args))

    def push_back(self, x):
        return _QuantLib.PeriodVector_push_back(self, x)

    def front(self):
        return _QuantLib.PeriodVector_front(self)

    def back(self):
        return _QuantLib.PeriodVector_back(self)

    def assign(self, n, x):
        return _QuantLib.PeriodVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.PeriodVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.PeriodVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.PeriodVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.PeriodVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_PeriodVector

# Register PeriodVector in _QuantLib:
_QuantLib.PeriodVector_swigregister(PeriodVector)


import datetime as _datetime

class Date(object):
    thisown = 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 hours(self):
        return _QuantLib.Date_hours(self)

    def minutes(self):
        return _QuantLib.Date_minutes(self)

    def seconds(self):
        return _QuantLib.Date_seconds(self)

    def milliseconds(self):
        return _QuantLib.Date_milliseconds(self)

    def microseconds(self):
        return _QuantLib.Date_microseconds(self)

    def fractionOfDay(self):
        return _QuantLib.Date_fractionOfDay(self)

    def fractionOfSecond(self):
        return _QuantLib.Date_fractionOfSecond(self)

    def serialNumber(self):
        return _QuantLib.Date_serialNumber(self)

    @staticmethod
    def isLeap(y):
        return _QuantLib.Date_isLeap(y)

    @staticmethod
    def minDate():
        return _QuantLib.Date_minDate()

    @staticmethod
    def maxDate():
        return _QuantLib.Date_maxDate()

    @staticmethod
    def todaysDate():
        return _QuantLib.Date_todaysDate()

    @staticmethod
    def localDateTime():
        return _QuantLib.Date_localDateTime()

    @staticmethod
    def universalDateTime():
        return _QuantLib.Date_universalDateTime()

    @staticmethod
    def endOfMonth(arg1):
        return _QuantLib.Date_endOfMonth(arg1)

    @staticmethod
    def isEndOfMonth(arg1):
        return _QuantLib.Date_isEndOfMonth(arg1)

    @staticmethod
    def nextWeekday(arg1, arg2):
        return _QuantLib.Date_nextWeekday(arg1, arg2)

    @staticmethod
    def nthWeekday(n, arg2, m, y):
        return _QuantLib.Date_nthWeekday(n, arg2, m, y)

    def __add__(self, *args):
        return _QuantLib.Date___add__(self, *args)

    def __init__(self, *args):
        _QuantLib.Date_swiginit(self, _QuantLib.new_Date(*args))

    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 __eq__(self, other):
        return _QuantLib.Date___eq__(self, other)

    def __cmp__(self, other):
        return _QuantLib.Date___cmp__(self, other)

    def __nonzero__(self):
        return _QuantLib.Date___nonzero__(self)

    def __bool__(self):
        return _QuantLib.Date___bool__(self)

    def __hash__(self):
        return _QuantLib.Date___hash__(self)

    def __lt__(self, other):
        return _QuantLib.Date___lt__(self, other)

    def __gt__(self, other):
        return _QuantLib.Date___gt__(self, other)

    def __le__(self, other):
        return _QuantLib.Date___le__(self, other)

    def __ge__(self, other):
        return _QuantLib.Date___ge__(self, other)

    def __ne__(self, other):
        return _QuantLib.Date___ne__(self, other)

    def to_date(self):
        return _datetime.date(self.year(), self.month(), self.dayOfMonth())

    @staticmethod
    def from_date(date):
        return Date(date.day, date.month, date.year)

    __swig_destroy__ = _QuantLib.delete_Date

# Register Date in _QuantLib:
_QuantLib.Date_swigregister(Date)

def Date_isLeap(y):
    return _QuantLib.Date_isLeap(y)

def Date_minDate():
    return _QuantLib.Date_minDate()

def Date_maxDate():
    return _QuantLib.Date_maxDate()

def Date_todaysDate():
    return _QuantLib.Date_todaysDate()

def Date_localDateTime():
    return _QuantLib.Date_localDateTime()

def Date_universalDateTime():
    return _QuantLib.Date_universalDateTime()

def Date_endOfMonth(arg1):
    return _QuantLib.Date_endOfMonth(arg1)

def Date_isEndOfMonth(arg1):
    return _QuantLib.Date_isEndOfMonth(arg1)

def Date_nextWeekday(arg1, arg2):
    return _QuantLib.Date_nextWeekday(arg1, arg2)

def Date_nthWeekday(n, arg2, m, y):
    return _QuantLib.Date_nthWeekday(n, arg2, m, y)

class DateParser(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def parseFormatted(str, fmt):
        return _QuantLib.DateParser_parseFormatted(str, fmt)

    @staticmethod
    def parseISO(str):
        return _QuantLib.DateParser_parseISO(str)

    @staticmethod
    def parse(str, fmt):
        return _QuantLib.DateParser_parse(str, fmt)

    def __init__(self):
        _QuantLib.DateParser_swiginit(self, _QuantLib.new_DateParser())
    __swig_destroy__ = _QuantLib.delete_DateParser

# Register DateParser in _QuantLib:
_QuantLib.DateParser_swigregister(DateParser)

def DateParser_parseFormatted(str, fmt):
    return _QuantLib.DateParser_parseFormatted(str, fmt)

def DateParser_parseISO(str):
    return _QuantLib.DateParser_parseISO(str)

def DateParser_parse(str, fmt):
    return _QuantLib.DateParser_parse(str, fmt)

class PeriodParser(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def parse(str):
        return _QuantLib.PeriodParser_parse(str)

    def __init__(self):
        _QuantLib.PeriodParser_swiginit(self, _QuantLib.new_PeriodParser())
    __swig_destroy__ = _QuantLib.delete_PeriodParser

# Register PeriodParser in _QuantLib:
_QuantLib.PeriodParser_swigregister(PeriodParser)

def PeriodParser_parse(str):
    return _QuantLib.PeriodParser_parse(str)


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 = 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 __getslice__(self, i, j):
        return _QuantLib.DateVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.DateVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.DateVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.DateVector_pop(self)

    def append(self, x):
        return _QuantLib.DateVector_append(self, x)

    def empty(self):
        return _QuantLib.DateVector_empty(self)

    def size(self):
        return _QuantLib.DateVector_size(self)

    def swap(self, v):
        return _QuantLib.DateVector_swap(self, v)

    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 clear(self):
        return _QuantLib.DateVector_clear(self)

    def get_allocator(self):
        return _QuantLib.DateVector_get_allocator(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):
        _QuantLib.DateVector_swiginit(self, _QuantLib.new_DateVector(*args))

    def push_back(self, x):
        return _QuantLib.DateVector_push_back(self, x)

    def front(self):
        return _QuantLib.DateVector_front(self)

    def back(self):
        return _QuantLib.DateVector_back(self)

    def assign(self, n, x):
        return _QuantLib.DateVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.DateVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.DateVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.DateVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.DateVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DateVector

# Register DateVector in _QuantLib:
_QuantLib.DateVector_swigregister(DateVector)


def daysBetween(arg1, arg2):
    return _QuantLib.daysBetween(arg1, arg2)
class IMM(object):
    thisown = 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

    @staticmethod
    def isIMMdate(d, mainCycle=True):
        return _QuantLib.IMM_isIMMdate(d, mainCycle)

    @staticmethod
    def isIMMcode(code, mainCycle=True):
        return _QuantLib.IMM_isIMMcode(code, mainCycle)

    @staticmethod
    def code(immDate):
        return _QuantLib.IMM_code(immDate)

    @staticmethod
    def date(*args):
        return _QuantLib.IMM_date(*args)

    @staticmethod
    def nextDate(*args):
        return _QuantLib.IMM_nextDate(*args)

    @staticmethod
    def nextCode(*args):
        return _QuantLib.IMM_nextCode(*args)

    def __init__(self):
        _QuantLib.IMM_swiginit(self, _QuantLib.new_IMM())
    __swig_destroy__ = _QuantLib.delete_IMM

# Register IMM in _QuantLib:
_QuantLib.IMM_swigregister(IMM)

def IMM_isIMMdate(d, mainCycle=True):
    return _QuantLib.IMM_isIMMdate(d, mainCycle)

def IMM_isIMMcode(code, mainCycle=True):
    return _QuantLib.IMM_isIMMcode(code, mainCycle)

def IMM_code(immDate):
    return _QuantLib.IMM_code(immDate)

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

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

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

class ASX(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    F = _QuantLib.ASX_F
    G = _QuantLib.ASX_G
    H = _QuantLib.ASX_H
    J = _QuantLib.ASX_J
    K = _QuantLib.ASX_K
    M = _QuantLib.ASX_M
    N = _QuantLib.ASX_N
    Q = _QuantLib.ASX_Q
    U = _QuantLib.ASX_U
    V = _QuantLib.ASX_V
    X = _QuantLib.ASX_X
    Z = _QuantLib.ASX_Z

    @staticmethod
    def isASXdate(d, mainCycle=True):
        return _QuantLib.ASX_isASXdate(d, mainCycle)

    @staticmethod
    def isASXcode(code, mainCycle=True):
        return _QuantLib.ASX_isASXcode(code, mainCycle)

    @staticmethod
    def code(asxDate):
        return _QuantLib.ASX_code(asxDate)

    @staticmethod
    def date(*args):
        return _QuantLib.ASX_date(*args)

    @staticmethod
    def nextDate(*args):
        return _QuantLib.ASX_nextDate(*args)

    @staticmethod
    def nextCode(*args):
        return _QuantLib.ASX_nextCode(*args)

    def __init__(self):
        _QuantLib.ASX_swiginit(self, _QuantLib.new_ASX())
    __swig_destroy__ = _QuantLib.delete_ASX

# Register ASX in _QuantLib:
_QuantLib.ASX_swigregister(ASX)

def ASX_isASXdate(d, mainCycle=True):
    return _QuantLib.ASX_isASXdate(d, mainCycle)

def ASX_isASXcode(code, mainCycle=True):
    return _QuantLib.ASX_isASXcode(code, mainCycle)

def ASX_code(asxDate):
    return _QuantLib.ASX_code(asxDate)

def ASX_date(*args):
    return _QuantLib.ASX_date(*args)

def ASX_nextDate(*args):
    return _QuantLib.ASX_nextDate(*args)

def ASX_nextCode(*args):
    return _QuantLib.ASX_nextCode(*args)

class IntVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.IntVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.IntVector_pop(self)

    def append(self, x):
        return _QuantLib.IntVector_append(self, x)

    def empty(self):
        return _QuantLib.IntVector_empty(self)

    def size(self):
        return _QuantLib.IntVector_size(self)

    def swap(self, v):
        return _QuantLib.IntVector_swap(self, v)

    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 clear(self):
        return _QuantLib.IntVector_clear(self)

    def get_allocator(self):
        return _QuantLib.IntVector_get_allocator(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):
        _QuantLib.IntVector_swiginit(self, _QuantLib.new_IntVector(*args))

    def push_back(self, x):
        return _QuantLib.IntVector_push_back(self, x)

    def front(self):
        return _QuantLib.IntVector_front(self)

    def back(self):
        return _QuantLib.IntVector_back(self)

    def assign(self, n, x):
        return _QuantLib.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.IntVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.IntVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.IntVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.IntVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_IntVector

# Register IntVector in _QuantLib:
_QuantLib.IntVector_swigregister(IntVector)

class UnsignedIntVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.UnsignedIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.UnsignedIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.UnsignedIntVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.UnsignedIntVector_pop(self)

    def append(self, x):
        return _QuantLib.UnsignedIntVector_append(self, x)

    def empty(self):
        return _QuantLib.UnsignedIntVector_empty(self)

    def size(self):
        return _QuantLib.UnsignedIntVector_size(self)

    def swap(self, v):
        return _QuantLib.UnsignedIntVector_swap(self, v)

    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 clear(self):
        return _QuantLib.UnsignedIntVector_clear(self)

    def get_allocator(self):
        return _QuantLib.UnsignedIntVector_get_allocator(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):
        _QuantLib.UnsignedIntVector_swiginit(self, _QuantLib.new_UnsignedIntVector(*args))

    def push_back(self, x):
        return _QuantLib.UnsignedIntVector_push_back(self, x)

    def front(self):
        return _QuantLib.UnsignedIntVector_front(self)

    def back(self):
        return _QuantLib.UnsignedIntVector_back(self)

    def assign(self, n, x):
        return _QuantLib.UnsignedIntVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.UnsignedIntVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.UnsignedIntVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.UnsignedIntVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_UnsignedIntVector

# Register UnsignedIntVector in _QuantLib:
_QuantLib.UnsignedIntVector_swigregister(UnsignedIntVector)

class DoubleVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.DoubleVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.DoubleVector_pop(self)

    def append(self, x):
        return _QuantLib.DoubleVector_append(self, x)

    def empty(self):
        return _QuantLib.DoubleVector_empty(self)

    def size(self):
        return _QuantLib.DoubleVector_size(self)

    def swap(self, v):
        return _QuantLib.DoubleVector_swap(self, v)

    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 clear(self):
        return _QuantLib.DoubleVector_clear(self)

    def get_allocator(self):
        return _QuantLib.DoubleVector_get_allocator(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):
        _QuantLib.DoubleVector_swiginit(self, _QuantLib.new_DoubleVector(*args))

    def push_back(self, x):
        return _QuantLib.DoubleVector_push_back(self, x)

    def front(self):
        return _QuantLib.DoubleVector_front(self)

    def back(self):
        return _QuantLib.DoubleVector_back(self)

    def assign(self, n, x):
        return _QuantLib.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.DoubleVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.DoubleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DoubleVector

# Register DoubleVector in _QuantLib:
_QuantLib.DoubleVector_swigregister(DoubleVector)

class StrVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.StrVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.StrVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.StrVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.StrVector_pop(self)

    def append(self, x):
        return _QuantLib.StrVector_append(self, x)

    def empty(self):
        return _QuantLib.StrVector_empty(self)

    def size(self):
        return _QuantLib.StrVector_size(self)

    def swap(self, v):
        return _QuantLib.StrVector_swap(self, v)

    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 clear(self):
        return _QuantLib.StrVector_clear(self)

    def get_allocator(self):
        return _QuantLib.StrVector_get_allocator(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):
        _QuantLib.StrVector_swiginit(self, _QuantLib.new_StrVector(*args))

    def push_back(self, x):
        return _QuantLib.StrVector_push_back(self, x)

    def front(self):
        return _QuantLib.StrVector_front(self)

    def back(self):
        return _QuantLib.StrVector_back(self)

    def assign(self, n, x):
        return _QuantLib.StrVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.StrVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.StrVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.StrVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.StrVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StrVector

# Register StrVector in _QuantLib:
_QuantLib.StrVector_swigregister(StrVector)

class BoolVector(object):
    thisown = 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.BoolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.BoolVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.BoolVector___bool__(self)

    def __len__(self):
        return _QuantLib.BoolVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.BoolVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.BoolVector_pop(self)

    def append(self, x):
        return _QuantLib.BoolVector_append(self, x)

    def empty(self):
        return _QuantLib.BoolVector_empty(self)

    def size(self):
        return _QuantLib.BoolVector_size(self)

    def swap(self, v):
        return _QuantLib.BoolVector_swap(self, v)

    def begin(self):
        return _QuantLib.BoolVector_begin(self)

    def end(self):
        return _QuantLib.BoolVector_end(self)

    def rbegin(self):
        return _QuantLib.BoolVector_rbegin(self)

    def rend(self):
        return _QuantLib.BoolVector_rend(self)

    def clear(self):
        return _QuantLib.BoolVector_clear(self)

    def get_allocator(self):
        return _QuantLib.BoolVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.BoolVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.BoolVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.BoolVector_swiginit(self, _QuantLib.new_BoolVector(*args))

    def push_back(self, x):
        return _QuantLib.BoolVector_push_back(self, x)

    def front(self):
        return _QuantLib.BoolVector_front(self)

    def back(self):
        return _QuantLib.BoolVector_back(self)

    def assign(self, n, x):
        return _QuantLib.BoolVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.BoolVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.BoolVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.BoolVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.BoolVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_BoolVector

# Register BoolVector in _QuantLib:
_QuantLib.BoolVector_swigregister(BoolVector)

class DoublePair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DoublePair_swiginit(self, _QuantLib.new_DoublePair(*args))
    first = property(_QuantLib.DoublePair_first_get, _QuantLib.DoublePair_first_set)
    second = property(_QuantLib.DoublePair_second_get, _QuantLib.DoublePair_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_DoublePair

# Register DoublePair in _QuantLib:
_QuantLib.DoublePair_swigregister(DoublePair)

class DoublePairVector(object):
    thisown = 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.DoublePairVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.DoublePairVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.DoublePairVector___bool__(self)

    def __len__(self):
        return _QuantLib.DoublePairVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.DoublePairVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.DoublePairVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.DoublePairVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.DoublePairVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.DoublePairVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.DoublePairVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.DoublePairVector_pop(self)

    def append(self, x):
        return _QuantLib.DoublePairVector_append(self, x)

    def empty(self):
        return _QuantLib.DoublePairVector_empty(self)

    def size(self):
        return _QuantLib.DoublePairVector_size(self)

    def swap(self, v):
        return _QuantLib.DoublePairVector_swap(self, v)

    def begin(self):
        return _QuantLib.DoublePairVector_begin(self)

    def end(self):
        return _QuantLib.DoublePairVector_end(self)

    def rbegin(self):
        return _QuantLib.DoublePairVector_rbegin(self)

    def rend(self):
        return _QuantLib.DoublePairVector_rend(self)

    def clear(self):
        return _QuantLib.DoublePairVector_clear(self)

    def get_allocator(self):
        return _QuantLib.DoublePairVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.DoublePairVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.DoublePairVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.DoublePairVector_swiginit(self, _QuantLib.new_DoublePairVector(*args))

    def push_back(self, x):
        return _QuantLib.DoublePairVector_push_back(self, x)

    def front(self):
        return _QuantLib.DoublePairVector_front(self)

    def back(self):
        return _QuantLib.DoublePairVector_back(self)

    def assign(self, n, x):
        return _QuantLib.DoublePairVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.DoublePairVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.DoublePairVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.DoublePairVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.DoublePairVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DoublePairVector

# Register DoublePairVector in _QuantLib:
_QuantLib.DoublePairVector_swigregister(DoublePairVector)

class PairDoubleVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PairDoubleVector_swiginit(self, _QuantLib.new_PairDoubleVector(*args))
    first = property(_QuantLib.PairDoubleVector_first_get, _QuantLib.PairDoubleVector_first_set)
    second = property(_QuantLib.PairDoubleVector_second_get, _QuantLib.PairDoubleVector_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_PairDoubleVector

# Register PairDoubleVector in _QuantLib:
_QuantLib.PairDoubleVector_swigregister(PairDoubleVector)

class NodePair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NodePair_swiginit(self, _QuantLib.new_NodePair(*args))
    first = property(_QuantLib.NodePair_first_get, _QuantLib.NodePair_first_set)
    second = 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

# Register NodePair in _QuantLib:
_QuantLib.NodePair_swigregister(NodePair)

class NodeVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.NodeVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.NodeVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.NodeVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.NodeVector_pop(self)

    def append(self, x):
        return _QuantLib.NodeVector_append(self, x)

    def empty(self):
        return _QuantLib.NodeVector_empty(self)

    def size(self):
        return _QuantLib.NodeVector_size(self)

    def swap(self, v):
        return _QuantLib.NodeVector_swap(self, v)

    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 clear(self):
        return _QuantLib.NodeVector_clear(self)

    def get_allocator(self):
        return _QuantLib.NodeVector_get_allocator(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):
        _QuantLib.NodeVector_swiginit(self, _QuantLib.new_NodeVector(*args))

    def push_back(self, x):
        return _QuantLib.NodeVector_push_back(self, x)

    def front(self):
        return _QuantLib.NodeVector_front(self)

    def back(self):
        return _QuantLib.NodeVector_back(self)

    def assign(self, n, x):
        return _QuantLib.NodeVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.NodeVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.NodeVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.NodeVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.NodeVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_NodeVector

# Register NodeVector in _QuantLib:
_QuantLib.NodeVector_swigregister(NodeVector)

class Exercise(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    American = _QuantLib.Exercise_American
    Bermudan = _QuantLib.Exercise_Bermudan
    European = _QuantLib.Exercise_European

    def __init__(self, type):
        _QuantLib.Exercise_swiginit(self, _QuantLib.new_Exercise(type))

    def type(self):
        return _QuantLib.Exercise_type(self)

    def date(self, index):
        return _QuantLib.Exercise_date(self, index)

    def dateAt(self, index):
        return _QuantLib.Exercise_dateAt(self, index)

    def dates(self):
        return _QuantLib.Exercise_dates(self)

    def lastDate(self):
        return _QuantLib.Exercise_lastDate(self)
    __swig_destroy__ = _QuantLib.delete_Exercise

# Register Exercise in _QuantLib:
_QuantLib.Exercise_swigregister(Exercise)

class EuropeanExercise(Exercise):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, date):
        _QuantLib.EuropeanExercise_swiginit(self, _QuantLib.new_EuropeanExercise(date))
    __swig_destroy__ = _QuantLib.delete_EuropeanExercise

# Register EuropeanExercise in _QuantLib:
_QuantLib.EuropeanExercise_swigregister(EuropeanExercise)

class AmericanExercise(Exercise):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, earliestDate, latestDate, payoffAtExpiry=False):
        _QuantLib.AmericanExercise_swiginit(self, _QuantLib.new_AmericanExercise(earliestDate, latestDate, payoffAtExpiry))
    __swig_destroy__ = _QuantLib.delete_AmericanExercise

# Register AmericanExercise in _QuantLib:
_QuantLib.AmericanExercise_swigregister(AmericanExercise)

class BermudanExercise(Exercise):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dates, payoffAtExpiry=False):
        _QuantLib.BermudanExercise_swiginit(self, _QuantLib.new_BermudanExercise(dates, payoffAtExpiry))
    __swig_destroy__ = _QuantLib.delete_BermudanExercise

# Register BermudanExercise in _QuantLib:
_QuantLib.BermudanExercise_swigregister(BermudanExercise)

class RebatedExercise(Exercise):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RebatedExercise_swiginit(self, _QuantLib.new_RebatedExercise(*args))
    __swig_destroy__ = _QuantLib.delete_RebatedExercise

# Register RebatedExercise in _QuantLib:
_QuantLib.RebatedExercise_swigregister(RebatedExercise)

class SwingExercise(Exercise):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dates):
        _QuantLib.SwingExercise_swiginit(self, _QuantLib.new_SwingExercise(dates))
    __swig_destroy__ = _QuantLib.delete_SwingExercise

# Register SwingExercise in _QuantLib:
_QuantLib.SwingExercise_swigregister(SwingExercise)

class Observable(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Observable_swiginit(self, _QuantLib.new_Observable())
    __swig_destroy__ = _QuantLib.delete_Observable

# Register Observable in _QuantLib:
_QuantLib.Observable_swigregister(Observable)

class Observer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        _QuantLib.Observer_swiginit(self, _QuantLib.new_Observer(callback))

    def _registerWith(self, arg2):
        return _QuantLib.Observer__registerWith(self, arg2)

    def _unregisterWith(self, arg2):
        return _QuantLib.Observer__unregisterWith(self, arg2)

    def registerWith(self,x):
        if hasattr(x, "asObservable"):
            self._registerWith(x.asObservable())
        else:
            self._registerWith(x)
    def unregisterWith(self,x):
        if hasattr(x, "asObservable"):
            self._unregisterWith(x.asObservable())
        else:
            self._unregisterWith(x)

    __swig_destroy__ = _QuantLib.delete_Observer

# Register Observer in _QuantLib:
_QuantLib.Observer_swigregister(Observer)

class Array(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Array_swiginit(self, _QuantLib.new_Array(*args))

    def __len__(self):
        return _QuantLib.Array___len__(self)

    def __str__(self):
        return _QuantLib.Array___str__(self)

    def __add__(self, a):
        return _QuantLib.Array___add__(self, a)

    def __sub__(self, a):
        return _QuantLib.Array___sub__(self, a)

    def __mul__(self, *args):
        return _QuantLib.Array___mul__(self, *args)

    def __div__(self, a):
        return _QuantLib.Array___div__(self, a)

    def __rmul__(self, a):
        return _QuantLib.Array___rmul__(self, a)

    def __getslice__(self, i, j):
        return _QuantLib.Array___getslice__(self, i, j)

    def __setslice__(self, i, j, rhs):
        return _QuantLib.Array___setslice__(self, i, j, rhs)

    def __nonzero__(self):
        return _QuantLib.Array___nonzero__(self)

    def __bool__(self):
        return _QuantLib.Array___bool__(self)

    def __getitem__(self, i):
        return _QuantLib.Array___getitem__(self, i)

    def __setitem__(self, i, x):
        return _QuantLib.Array___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_Array

# Register Array in _QuantLib:
_QuantLib.Array_swigregister(Array)

class DefaultLexicographicalViewColumn(object):
    thisown = 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, i):
        return _QuantLib.DefaultLexicographicalViewColumn___getitem__(self, i)

    def __setitem__(self, i, x):
        return _QuantLib.DefaultLexicographicalViewColumn___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_DefaultLexicographicalViewColumn

# Register DefaultLexicographicalViewColumn in _QuantLib:
_QuantLib.DefaultLexicographicalViewColumn_swigregister(DefaultLexicographicalViewColumn)

class LexicographicalView(object):
    thisown = 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, a, xSize):
        _QuantLib.LexicographicalView_swiginit(self, _QuantLib.new_LexicographicalView(a, xSize))

    def __str__(self):
        return _QuantLib.LexicographicalView___str__(self)

    def __getitem__(self, i):
        return _QuantLib.LexicographicalView___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_LexicographicalView

# Register LexicographicalView in _QuantLib:
_QuantLib.LexicographicalView_swigregister(LexicographicalView)

class MatrixRow(object):
    thisown = 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, i):
        return _QuantLib.MatrixRow___getitem__(self, i)

    def __setitem__(self, i, x):
        return _QuantLib.MatrixRow___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_MatrixRow

# Register MatrixRow in _QuantLib:
_QuantLib.MatrixRow_swigregister(MatrixRow)

class Matrix(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Matrix_swiginit(self, _QuantLib.new_Matrix(*args))

    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, m):
        return _QuantLib.Matrix___add__(self, m)

    def __sub__(self, m):
        return _QuantLib.Matrix___sub__(self, m)

    def __mul__(self, *args):
        return _QuantLib.Matrix___mul__(self, *args)

    def __div__(self, x):
        return _QuantLib.Matrix___div__(self, x)

    def __getitem__(self, i):
        return _QuantLib.Matrix___getitem__(self, i)

    def __rmul__(self, *args):
        return _QuantLib.Matrix___rmul__(self, *args)
    __swig_destroy__ = _QuantLib.delete_Matrix

# Register Matrix in _QuantLib:
_QuantLib.Matrix_swigregister(Matrix)

class SalvagingAlgorithm(object):
    thisown = 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):
        _QuantLib.SalvagingAlgorithm_swiginit(self, _QuantLib.new_SalvagingAlgorithm())
    __swig_destroy__ = _QuantLib.delete_SalvagingAlgorithm

# Register SalvagingAlgorithm in _QuantLib:
_QuantLib.SalvagingAlgorithm_swigregister(SalvagingAlgorithm)


def inverse(m):
    return _QuantLib.inverse(m)

def transpose(m):
    return _QuantLib.transpose(m)

def outerProduct(v1, v2):
    return _QuantLib.outerProduct(v1, v2)

def pseudoSqrt(m, a):
    return _QuantLib.pseudoSqrt(m, a)
class SVD(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _QuantLib.SVD_swiginit(self, _QuantLib.new_SVD(arg2))

    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

# Register SVD in _QuantLib:
_QuantLib.SVD_swigregister(SVD)

class MatrixMultiplicationProxy(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, matrixMult):
        _QuantLib.MatrixMultiplicationProxy_swiginit(self, _QuantLib.new_MatrixMultiplicationProxy(matrixMult))

    def __call__(self, x):
        return _QuantLib.MatrixMultiplicationProxy___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_MatrixMultiplicationProxy

# Register MatrixMultiplicationProxy in _QuantLib:
_QuantLib.MatrixMultiplicationProxy_swigregister(MatrixMultiplicationProxy)

class BiCGstab(object):
    thisown = 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.BiCGstab_solve(self, *args)

    def __init__(self, *args):
        _QuantLib.BiCGstab_swiginit(self, _QuantLib.new_BiCGstab(*args))
    __swig_destroy__ = _QuantLib.delete_BiCGstab

# Register BiCGstab in _QuantLib:
_QuantLib.BiCGstab_swigregister(BiCGstab)

class GMRES(object):
    thisown = 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.GMRES_solve(self, *args)

    def solveWithRestart(self, *args):
        return _QuantLib.GMRES_solveWithRestart(self, *args)

    def __init__(self, *args):
        _QuantLib.GMRES_swiginit(self, _QuantLib.new_GMRES(*args))
    __swig_destroy__ = _QuantLib.delete_GMRES

# Register GMRES in _QuantLib:
_QuantLib.GMRES_swigregister(GMRES)


def close(*args):
    return _QuantLib.close(*args)

def close_enough(*args):
    return _QuantLib.close_enough(*args)
class Quote(Observable):
    thisown = 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.Quote_value(self)

    def isValid(self):
        return _QuantLib.Quote_isValid(self)
    __swig_destroy__ = _QuantLib.delete_Quote

# Register Quote in _QuantLib:
_QuantLib.Quote_swigregister(Quote)

class QuoteHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.QuoteHandle_swiginit(self, _QuantLib.new_QuoteHandle(*args))

    def __deref__(self):
        return _QuantLib.QuoteHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.QuoteHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.QuoteHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.QuoteHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.QuoteHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandle

    def value(self):
        return _QuantLib.QuoteHandle_value(self)

    def isValid(self):
        return _QuantLib.QuoteHandle_isValid(self)

# Register QuoteHandle in _QuantLib:
_QuantLib.QuoteHandle_swigregister(QuoteHandle)

class RelinkableQuoteHandle(QuoteHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableQuoteHandle_swiginit(self, _QuantLib.new_RelinkableQuoteHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableQuoteHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableQuoteHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandle

# Register RelinkableQuoteHandle in _QuantLib:
_QuantLib.RelinkableQuoteHandle_swigregister(RelinkableQuoteHandle)

class SimpleQuote(Quote):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, value):
        _QuantLib.SimpleQuote_swiginit(self, _QuantLib.new_SimpleQuote(value))

    def setValue(self, value):
        return _QuantLib.SimpleQuote_setValue(self, value)
    __swig_destroy__ = _QuantLib.delete_SimpleQuote

# Register SimpleQuote in _QuantLib:
_QuantLib.SimpleQuote_swigregister(SimpleQuote)

class DerivedQuote(Quote):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, h, function):
        _QuantLib.DerivedQuote_swiginit(self, _QuantLib.new_DerivedQuote(h, function))
    __swig_destroy__ = _QuantLib.delete_DerivedQuote

# Register DerivedQuote in _QuantLib:
_QuantLib.DerivedQuote_swigregister(DerivedQuote)

class CompositeQuote(Quote):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, h1, h2, function):
        _QuantLib.CompositeQuote_swiginit(self, _QuantLib.new_CompositeQuote(h1, h2, function))
    __swig_destroy__ = _QuantLib.delete_CompositeQuote

# Register CompositeQuote in _QuantLib:
_QuantLib.CompositeQuote_swigregister(CompositeQuote)

class QuoteVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.QuoteVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.QuoteVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.QuoteVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.QuoteVector_pop(self)

    def append(self, x):
        return _QuantLib.QuoteVector_append(self, x)

    def empty(self):
        return _QuantLib.QuoteVector_empty(self)

    def size(self):
        return _QuantLib.QuoteVector_size(self)

    def swap(self, v):
        return _QuantLib.QuoteVector_swap(self, v)

    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 clear(self):
        return _QuantLib.QuoteVector_clear(self)

    def get_allocator(self):
        return _QuantLib.QuoteVector_get_allocator(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):
        _QuantLib.QuoteVector_swiginit(self, _QuantLib.new_QuoteVector(*args))

    def push_back(self, x):
        return _QuantLib.QuoteVector_push_back(self, x)

    def front(self):
        return _QuantLib.QuoteVector_front(self)

    def back(self):
        return _QuantLib.QuoteVector_back(self)

    def assign(self, n, x):
        return _QuantLib.QuoteVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.QuoteVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.QuoteVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.QuoteVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.QuoteVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteVector

# Register QuoteVector in _QuantLib:
_QuantLib.QuoteVector_swigregister(QuoteVector)

class QuoteVectorVector(object):
    thisown = 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.QuoteVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.QuoteVectorVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.QuoteVectorVector___bool__(self)

    def __len__(self):
        return _QuantLib.QuoteVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.QuoteVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.QuoteVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.QuoteVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.QuoteVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.QuoteVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.QuoteVectorVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.QuoteVectorVector_pop(self)

    def append(self, x):
        return _QuantLib.QuoteVectorVector_append(self, x)

    def empty(self):
        return _QuantLib.QuoteVectorVector_empty(self)

    def size(self):
        return _QuantLib.QuoteVectorVector_size(self)

    def swap(self, v):
        return _QuantLib.QuoteVectorVector_swap(self, v)

    def begin(self):
        return _QuantLib.QuoteVectorVector_begin(self)

    def end(self):
        return _QuantLib.QuoteVectorVector_end(self)

    def rbegin(self):
        return _QuantLib.QuoteVectorVector_rbegin(self)

    def rend(self):
        return _QuantLib.QuoteVectorVector_rend(self)

    def clear(self):
        return _QuantLib.QuoteVectorVector_clear(self)

    def get_allocator(self):
        return _QuantLib.QuoteVectorVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.QuoteVectorVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.QuoteVectorVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.QuoteVectorVector_swiginit(self, _QuantLib.new_QuoteVectorVector(*args))

    def push_back(self, x):
        return _QuantLib.QuoteVectorVector_push_back(self, x)

    def front(self):
        return _QuantLib.QuoteVectorVector_front(self)

    def back(self):
        return _QuantLib.QuoteVectorVector_back(self)

    def assign(self, n, x):
        return _QuantLib.QuoteVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.QuoteVectorVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.QuoteVectorVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.QuoteVectorVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.QuoteVectorVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteVectorVector

# Register QuoteVectorVector in _QuantLib:
_QuantLib.QuoteVectorVector_swigregister(QuoteVectorVector)

class QuoteHandleVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.QuoteHandleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.QuoteHandleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.QuoteHandleVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.QuoteHandleVector_pop(self)

    def append(self, x):
        return _QuantLib.QuoteHandleVector_append(self, x)

    def empty(self):
        return _QuantLib.QuoteHandleVector_empty(self)

    def size(self):
        return _QuantLib.QuoteHandleVector_size(self)

    def swap(self, v):
        return _QuantLib.QuoteHandleVector_swap(self, v)

    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 clear(self):
        return _QuantLib.QuoteHandleVector_clear(self)

    def get_allocator(self):
        return _QuantLib.QuoteHandleVector_get_allocator(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):
        _QuantLib.QuoteHandleVector_swiginit(self, _QuantLib.new_QuoteHandleVector(*args))

    def push_back(self, x):
        return _QuantLib.QuoteHandleVector_push_back(self, x)

    def front(self):
        return _QuantLib.QuoteHandleVector_front(self)

    def back(self):
        return _QuantLib.QuoteHandleVector_back(self)

    def assign(self, n, x):
        return _QuantLib.QuoteHandleVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.QuoteHandleVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.QuoteHandleVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.QuoteHandleVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.QuoteHandleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandleVector

# Register QuoteHandleVector in _QuantLib:
_QuantLib.QuoteHandleVector_swigregister(QuoteHandleVector)

class QuoteHandleVectorVector(object):
    thisown = 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.QuoteHandleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.QuoteHandleVectorVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.QuoteHandleVectorVector___bool__(self)

    def __len__(self):
        return _QuantLib.QuoteHandleVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.QuoteHandleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.QuoteHandleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.QuoteHandleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.QuoteHandleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.QuoteHandleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.QuoteHandleVectorVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.QuoteHandleVectorVector_pop(self)

    def append(self, x):
        return _QuantLib.QuoteHandleVectorVector_append(self, x)

    def empty(self):
        return _QuantLib.QuoteHandleVectorVector_empty(self)

    def size(self):
        return _QuantLib.QuoteHandleVectorVector_size(self)

    def swap(self, v):
        return _QuantLib.QuoteHandleVectorVector_swap(self, v)

    def begin(self):
        return _QuantLib.QuoteHandleVectorVector_begin(self)

    def end(self):
        return _QuantLib.QuoteHandleVectorVector_end(self)

    def rbegin(self):
        return _QuantLib.QuoteHandleVectorVector_rbegin(self)

    def rend(self):
        return _QuantLib.QuoteHandleVectorVector_rend(self)

    def clear(self):
        return _QuantLib.QuoteHandleVectorVector_clear(self)

    def get_allocator(self):
        return _QuantLib.QuoteHandleVectorVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.QuoteHandleVectorVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.QuoteHandleVectorVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.QuoteHandleVectorVector_swiginit(self, _QuantLib.new_QuoteHandleVectorVector(*args))

    def push_back(self, x):
        return _QuantLib.QuoteHandleVectorVector_push_back(self, x)

    def front(self):
        return _QuantLib.QuoteHandleVectorVector_front(self)

    def back(self):
        return _QuantLib.QuoteHandleVectorVector_back(self)

    def assign(self, n, x):
        return _QuantLib.QuoteHandleVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.QuoteHandleVectorVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.QuoteHandleVectorVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.QuoteHandleVectorVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.QuoteHandleVectorVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_QuoteHandleVectorVector

# Register QuoteHandleVectorVector in _QuantLib:
_QuantLib.QuoteHandleVectorVector_swigregister(QuoteHandleVectorVector)

class RelinkableQuoteHandleVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.RelinkableQuoteHandleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.RelinkableQuoteHandleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.RelinkableQuoteHandleVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.RelinkableQuoteHandleVector_pop(self)

    def append(self, x):
        return _QuantLib.RelinkableQuoteHandleVector_append(self, x)

    def empty(self):
        return _QuantLib.RelinkableQuoteHandleVector_empty(self)

    def size(self):
        return _QuantLib.RelinkableQuoteHandleVector_size(self)

    def swap(self, v):
        return _QuantLib.RelinkableQuoteHandleVector_swap(self, v)

    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 clear(self):
        return _QuantLib.RelinkableQuoteHandleVector_clear(self)

    def get_allocator(self):
        return _QuantLib.RelinkableQuoteHandleVector_get_allocator(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):
        _QuantLib.RelinkableQuoteHandleVector_swiginit(self, _QuantLib.new_RelinkableQuoteHandleVector(*args))

    def push_back(self, x):
        return _QuantLib.RelinkableQuoteHandleVector_push_back(self, x)

    def front(self):
        return _QuantLib.RelinkableQuoteHandleVector_front(self)

    def back(self):
        return _QuantLib.RelinkableQuoteHandleVector_back(self)

    def assign(self, n, x):
        return _QuantLib.RelinkableQuoteHandleVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.RelinkableQuoteHandleVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.RelinkableQuoteHandleVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.RelinkableQuoteHandleVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.RelinkableQuoteHandleVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandleVector

# Register RelinkableQuoteHandleVector in _QuantLib:
_QuantLib.RelinkableQuoteHandleVector_swigregister(RelinkableQuoteHandleVector)

class RelinkableQuoteHandleVectorVector(object):
    thisown = 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.RelinkableQuoteHandleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector___bool__(self)

    def __len__(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.RelinkableQuoteHandleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.RelinkableQuoteHandleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_pop(self)

    def append(self, x):
        return _QuantLib.RelinkableQuoteHandleVectorVector_append(self, x)

    def empty(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_empty(self)

    def size(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_size(self)

    def swap(self, v):
        return _QuantLib.RelinkableQuoteHandleVectorVector_swap(self, v)

    def begin(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_begin(self)

    def end(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_end(self)

    def rbegin(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_rbegin(self)

    def rend(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_rend(self)

    def clear(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_clear(self)

    def get_allocator(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.RelinkableQuoteHandleVectorVector_swiginit(self, _QuantLib.new_RelinkableQuoteHandleVectorVector(*args))

    def push_back(self, x):
        return _QuantLib.RelinkableQuoteHandleVectorVector_push_back(self, x)

    def front(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_front(self)

    def back(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_back(self)

    def assign(self, n, x):
        return _QuantLib.RelinkableQuoteHandleVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.RelinkableQuoteHandleVectorVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.RelinkableQuoteHandleVectorVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.RelinkableQuoteHandleVectorVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandleVectorVector

# Register RelinkableQuoteHandleVectorVector in _QuantLib:
_QuantLib.RelinkableQuoteHandleVectorVector_swigregister(RelinkableQuoteHandleVectorVector)

Following = _QuantLib.Following
ModifiedFollowing = _QuantLib.ModifiedFollowing
Preceding = _QuantLib.Preceding
ModifiedPreceding = _QuantLib.ModifiedPreceding
Unadjusted = _QuantLib.Unadjusted
HalfMonthModifiedFollowing = _QuantLib.HalfMonthModifiedFollowing
JoinHolidays = _QuantLib.JoinHolidays
JoinBusinessDays = _QuantLib.JoinBusinessDays
class Calendar(object):
    thisown = 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 isWeekend(self, w):
        return _QuantLib.Calendar_isWeekend(self, w)

    def endOfMonth(self, arg2):
        return _QuantLib.Calendar_endOfMonth(self, arg2)

    def isBusinessDay(self, arg2):
        return _QuantLib.Calendar_isBusinessDay(self, arg2)

    def isHoliday(self, arg2):
        return _QuantLib.Calendar_isHoliday(self, arg2)

    def isEndOfMonth(self, arg2):
        return _QuantLib.Calendar_isEndOfMonth(self, arg2)

    def addHoliday(self, arg2):
        return _QuantLib.Calendar_addHoliday(self, arg2)

    def removeHoliday(self, arg2):
        return _QuantLib.Calendar_removeHoliday(self, arg2)

    def adjust(self, *args):
        return _QuantLib.Calendar_adjust(self, *args)

    def advance(self, *args):
        return _QuantLib.Calendar_advance(self, *args)

    def businessDaysBetween(self, _from, to, includeFirst=True, includeLast=False):
        return _QuantLib.Calendar_businessDaysBetween(self, _from, to, includeFirst, includeLast)

    def holidayList(self, _from, to, includeWeekEnds=False):
        return _QuantLib.Calendar_holidayList(self, _from, to, includeWeekEnds)

    def businessDayList(self, _from, to):
        return _QuantLib.Calendar_businessDayList(self, _from, to)

    def name(self):
        return _QuantLib.Calendar_name(self)

    def __str__(self):
        return _QuantLib.Calendar___str__(self)

    def __eq__(self, other):
        return _QuantLib.Calendar___eq__(self, other)

    def __ne__(self, other):
        return _QuantLib.Calendar___ne__(self, other)

    def __hash__(self):
        return hash(self.name())

    __swig_destroy__ = _QuantLib.delete_Calendar

# Register Calendar in _QuantLib:
_QuantLib.Calendar_swigregister(Calendar)

class Argentina(Calendar):
    thisown = 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):
        _QuantLib.Argentina_swiginit(self, _QuantLib.new_Argentina(*args))
    __swig_destroy__ = _QuantLib.delete_Argentina

# Register Argentina in _QuantLib:
_QuantLib.Argentina_swigregister(Argentina)

class Australia(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Australia_swiginit(self, _QuantLib.new_Australia())
    __swig_destroy__ = _QuantLib.delete_Australia

# Register Australia in _QuantLib:
_QuantLib.Australia_swigregister(Australia)

class Brazil(Calendar):
    thisown = 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):
        _QuantLib.Brazil_swiginit(self, _QuantLib.new_Brazil(*args))
    __swig_destroy__ = _QuantLib.delete_Brazil

# Register Brazil in _QuantLib:
_QuantLib.Brazil_swigregister(Brazil)

class Canada(Calendar):
    thisown = 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):
        _QuantLib.Canada_swiginit(self, _QuantLib.new_Canada(*args))
    __swig_destroy__ = _QuantLib.delete_Canada

# Register Canada in _QuantLib:
_QuantLib.Canada_swigregister(Canada)

class China(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SSE = _QuantLib.China_SSE
    IB = _QuantLib.China_IB

    def __init__(self, *args):
        _QuantLib.China_swiginit(self, _QuantLib.new_China(*args))
    __swig_destroy__ = _QuantLib.delete_China

# Register China in _QuantLib:
_QuantLib.China_swigregister(China)

class CzechRepublic(Calendar):
    thisown = 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):
        _QuantLib.CzechRepublic_swiginit(self, _QuantLib.new_CzechRepublic(*args))
    __swig_destroy__ = _QuantLib.delete_CzechRepublic

# Register CzechRepublic in _QuantLib:
_QuantLib.CzechRepublic_swigregister(CzechRepublic)

class Denmark(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Denmark_swiginit(self, _QuantLib.new_Denmark())
    __swig_destroy__ = _QuantLib.delete_Denmark

# Register Denmark in _QuantLib:
_QuantLib.Denmark_swigregister(Denmark)

class Finland(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Finland_swiginit(self, _QuantLib.new_Finland())
    __swig_destroy__ = _QuantLib.delete_Finland

# Register Finland in _QuantLib:
_QuantLib.Finland_swigregister(Finland)

class France(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.France_Settlement
    Exchange = _QuantLib.France_Exchange

    def __init__(self, *args):
        _QuantLib.France_swiginit(self, _QuantLib.new_France(*args))
    __swig_destroy__ = _QuantLib.delete_France

# Register France in _QuantLib:
_QuantLib.France_swigregister(France)

class Germany(Calendar):
    thisown = 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):
        _QuantLib.Germany_swiginit(self, _QuantLib.new_Germany(*args))
    __swig_destroy__ = _QuantLib.delete_Germany

# Register Germany in _QuantLib:
_QuantLib.Germany_swigregister(Germany)

class HongKong(Calendar):
    thisown = 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):
        _QuantLib.HongKong_swiginit(self, _QuantLib.new_HongKong(*args))
    __swig_destroy__ = _QuantLib.delete_HongKong

# Register HongKong in _QuantLib:
_QuantLib.HongKong_swigregister(HongKong)

class Hungary(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Hungary_swiginit(self, _QuantLib.new_Hungary())
    __swig_destroy__ = _QuantLib.delete_Hungary

# Register Hungary in _QuantLib:
_QuantLib.Hungary_swigregister(Hungary)

class Iceland(Calendar):
    thisown = 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):
        _QuantLib.Iceland_swiginit(self, _QuantLib.new_Iceland(*args))
    __swig_destroy__ = _QuantLib.delete_Iceland

# Register Iceland in _QuantLib:
_QuantLib.Iceland_swigregister(Iceland)

class India(Calendar):
    thisown = 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):
        _QuantLib.India_swiginit(self, _QuantLib.new_India(*args))
    __swig_destroy__ = _QuantLib.delete_India

# Register India in _QuantLib:
_QuantLib.India_swigregister(India)

class Indonesia(Calendar):
    thisown = 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):
        _QuantLib.Indonesia_swiginit(self, _QuantLib.new_Indonesia(*args))
    __swig_destroy__ = _QuantLib.delete_Indonesia

# Register Indonesia in _QuantLib:
_QuantLib.Indonesia_swigregister(Indonesia)

class Israel(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.Israel_Settlement
    TASE = _QuantLib.Israel_TASE

    def __init__(self, *args):
        _QuantLib.Israel_swiginit(self, _QuantLib.new_Israel(*args))
    __swig_destroy__ = _QuantLib.delete_Israel

# Register Israel in _QuantLib:
_QuantLib.Israel_swigregister(Israel)

class Italy(Calendar):
    thisown = 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):
        _QuantLib.Italy_swiginit(self, _QuantLib.new_Italy(*args))
    __swig_destroy__ = _QuantLib.delete_Italy

# Register Italy in _QuantLib:
_QuantLib.Italy_swigregister(Italy)

class Japan(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Japan_swiginit(self, _QuantLib.new_Japan())
    __swig_destroy__ = _QuantLib.delete_Japan

# Register Japan in _QuantLib:
_QuantLib.Japan_swigregister(Japan)

class Mexico(Calendar):
    thisown = 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):
        _QuantLib.Mexico_swiginit(self, _QuantLib.new_Mexico(*args))
    __swig_destroy__ = _QuantLib.delete_Mexico

# Register Mexico in _QuantLib:
_QuantLib.Mexico_swigregister(Mexico)

class NewZealand(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NewZealand_swiginit(self, _QuantLib.new_NewZealand())
    __swig_destroy__ = _QuantLib.delete_NewZealand

# Register NewZealand in _QuantLib:
_QuantLib.NewZealand_swigregister(NewZealand)

class Norway(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Norway_swiginit(self, _QuantLib.new_Norway())
    __swig_destroy__ = _QuantLib.delete_Norway

# Register Norway in _QuantLib:
_QuantLib.Norway_swigregister(Norway)

class Poland(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Poland_swiginit(self, _QuantLib.new_Poland())
    __swig_destroy__ = _QuantLib.delete_Poland

# Register Poland in _QuantLib:
_QuantLib.Poland_swigregister(Poland)

class Russia(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Settlement = _QuantLib.Russia_Settlement
    MOEX = _QuantLib.Russia_MOEX

    def __init__(self, *args):
        _QuantLib.Russia_swiginit(self, _QuantLib.new_Russia(*args))
    __swig_destroy__ = _QuantLib.delete_Russia

# Register Russia in _QuantLib:
_QuantLib.Russia_swigregister(Russia)

class Romania(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Romania_swiginit(self, _QuantLib.new_Romania())
    __swig_destroy__ = _QuantLib.delete_Romania

# Register Romania in _QuantLib:
_QuantLib.Romania_swigregister(Romania)

class SaudiArabia(Calendar):
    thisown = 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):
        _QuantLib.SaudiArabia_swiginit(self, _QuantLib.new_SaudiArabia(*args))
    __swig_destroy__ = _QuantLib.delete_SaudiArabia

# Register SaudiArabia in _QuantLib:
_QuantLib.SaudiArabia_swigregister(SaudiArabia)

class Singapore(Calendar):
    thisown = 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):
        _QuantLib.Singapore_swiginit(self, _QuantLib.new_Singapore(*args))
    __swig_destroy__ = _QuantLib.delete_Singapore

# Register Singapore in _QuantLib:
_QuantLib.Singapore_swigregister(Singapore)

class Slovakia(Calendar):
    thisown = 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):
        _QuantLib.Slovakia_swiginit(self, _QuantLib.new_Slovakia(*args))
    __swig_destroy__ = _QuantLib.delete_Slovakia

# Register Slovakia in _QuantLib:
_QuantLib.Slovakia_swigregister(Slovakia)

class SouthAfrica(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SouthAfrica_swiginit(self, _QuantLib.new_SouthAfrica())
    __swig_destroy__ = _QuantLib.delete_SouthAfrica

# Register SouthAfrica in _QuantLib:
_QuantLib.SouthAfrica_swigregister(SouthAfrica)

class SouthKorea(Calendar):
    thisown = 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):
        _QuantLib.SouthKorea_swiginit(self, _QuantLib.new_SouthKorea(*args))
    __swig_destroy__ = _QuantLib.delete_SouthKorea

# Register SouthKorea in _QuantLib:
_QuantLib.SouthKorea_swigregister(SouthKorea)

class Sweden(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Sweden_swiginit(self, _QuantLib.new_Sweden())
    __swig_destroy__ = _QuantLib.delete_Sweden

# Register Sweden in _QuantLib:
_QuantLib.Sweden_swigregister(Sweden)

class Switzerland(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Switzerland_swiginit(self, _QuantLib.new_Switzerland())
    __swig_destroy__ = _QuantLib.delete_Switzerland

# Register Switzerland in _QuantLib:
_QuantLib.Switzerland_swigregister(Switzerland)

class Taiwan(Calendar):
    thisown = 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):
        _QuantLib.Taiwan_swiginit(self, _QuantLib.new_Taiwan(*args))
    __swig_destroy__ = _QuantLib.delete_Taiwan

# Register Taiwan in _QuantLib:
_QuantLib.Taiwan_swigregister(Taiwan)

class TARGET(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.TARGET_swiginit(self, _QuantLib.new_TARGET())
    __swig_destroy__ = _QuantLib.delete_TARGET

# Register TARGET in _QuantLib:
_QuantLib.TARGET_swigregister(TARGET)

class Thailand(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Thailand_swiginit(self, _QuantLib.new_Thailand())
    __swig_destroy__ = _QuantLib.delete_Thailand

# Register Thailand in _QuantLib:
_QuantLib.Thailand_swigregister(Thailand)

class Turkey(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Turkey_swiginit(self, _QuantLib.new_Turkey())
    __swig_destroy__ = _QuantLib.delete_Turkey

# Register Turkey in _QuantLib:
_QuantLib.Turkey_swigregister(Turkey)

class Ukraine(Calendar):
    thisown = 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):
        _QuantLib.Ukraine_swiginit(self, _QuantLib.new_Ukraine(*args))
    __swig_destroy__ = _QuantLib.delete_Ukraine

# Register Ukraine in _QuantLib:
_QuantLib.Ukraine_swigregister(Ukraine)

class UnitedKingdom(Calendar):
    thisown = 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):
        _QuantLib.UnitedKingdom_swiginit(self, _QuantLib.new_UnitedKingdom(*args))
    __swig_destroy__ = _QuantLib.delete_UnitedKingdom

# Register UnitedKingdom in _QuantLib:
_QuantLib.UnitedKingdom_swigregister(UnitedKingdom)

class UnitedStates(Calendar):
    thisown = 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
    LiborImpact = _QuantLib.UnitedStates_LiborImpact
    FederalReserve = _QuantLib.UnitedStates_FederalReserve

    def __init__(self, *args):
        _QuantLib.UnitedStates_swiginit(self, _QuantLib.new_UnitedStates(*args))
    __swig_destroy__ = _QuantLib.delete_UnitedStates

# Register UnitedStates in _QuantLib:
_QuantLib.UnitedStates_swigregister(UnitedStates)

class NullCalendar(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NullCalendar_swiginit(self, _QuantLib.new_NullCalendar())
    __swig_destroy__ = _QuantLib.delete_NullCalendar

# Register NullCalendar in _QuantLib:
_QuantLib.NullCalendar_swigregister(NullCalendar)

class WeekendsOnly(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.WeekendsOnly_swiginit(self, _QuantLib.new_WeekendsOnly())
    __swig_destroy__ = _QuantLib.delete_WeekendsOnly

# Register WeekendsOnly in _QuantLib:
_QuantLib.WeekendsOnly_swigregister(WeekendsOnly)

class JointCalendar(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.JointCalendar_swiginit(self, _QuantLib.new_JointCalendar(*args))
    __swig_destroy__ = _QuantLib.delete_JointCalendar

# Register JointCalendar in _QuantLib:
_QuantLib.JointCalendar_swigregister(JointCalendar)

class BespokeCalendar(Calendar):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name):
        _QuantLib.BespokeCalendar_swiginit(self, _QuantLib.new_BespokeCalendar(name))

    def addWeekend(self, arg2):
        return _QuantLib.BespokeCalendar_addWeekend(self, arg2)
    __swig_destroy__ = _QuantLib.delete_BespokeCalendar

# Register BespokeCalendar in _QuantLib:
_QuantLib.BespokeCalendar_swigregister(BespokeCalendar)


def nullInt():
    return _QuantLib.nullInt()

def nullDouble():
    return _QuantLib.nullDouble()
class DayCounter(object):
    thisown = 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, d1, d2):
        return _QuantLib.DayCounter_dayCount(self, d1, d2)

    def yearFraction(self, *args):
        return _QuantLib.DayCounter_yearFraction(self, *args)

    def name(self):
        return _QuantLib.DayCounter_name(self)

    def __str__(self):
        return _QuantLib.DayCounter___str__(self)

    def __eq__(self, other):
        return _QuantLib.DayCounter___eq__(self, other)

    def __ne__(self, other):
        return _QuantLib.DayCounter___ne__(self, other)

    def __hash__(self):
        return hash(self.name())

    __swig_destroy__ = _QuantLib.delete_DayCounter

# Register DayCounter in _QuantLib:
_QuantLib.DayCounter_swigregister(DayCounter)

class Actual360(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, includeLastDay=False):
        _QuantLib.Actual360_swiginit(self, _QuantLib.new_Actual360(includeLastDay))
    __swig_destroy__ = _QuantLib.delete_Actual360

# Register Actual360 in _QuantLib:
_QuantLib.Actual360_swigregister(Actual360)

class Actual364(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Actual364_swiginit(self, _QuantLib.new_Actual364())
    __swig_destroy__ = _QuantLib.delete_Actual364

# Register Actual364 in _QuantLib:
_QuantLib.Actual364_swigregister(Actual364)

class Actual365Fixed(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Standard = _QuantLib.Actual365Fixed_Standard
    Canadian = _QuantLib.Actual365Fixed_Canadian
    NoLeap = _QuantLib.Actual365Fixed_NoLeap

    def __init__(self, *args):
        _QuantLib.Actual365Fixed_swiginit(self, _QuantLib.new_Actual365Fixed(*args))
    __swig_destroy__ = _QuantLib.delete_Actual365Fixed

# Register Actual365Fixed in _QuantLib:
_QuantLib.Actual365Fixed_swigregister(Actual365Fixed)

class Thirty360(DayCounter):
    thisown = 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):
        _QuantLib.Thirty360_swiginit(self, _QuantLib.new_Thirty360(*args))
    __swig_destroy__ = _QuantLib.delete_Thirty360

# Register Thirty360 in _QuantLib:
_QuantLib.Thirty360_swigregister(Thirty360)

class Thirty365(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Thirty365_swiginit(self, _QuantLib.new_Thirty365())
    __swig_destroy__ = _QuantLib.delete_Thirty365

# Register Thirty365 in _QuantLib:
_QuantLib.Thirty365_swigregister(Thirty365)

class ActualActual(DayCounter):
    thisown = 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):
        _QuantLib.ActualActual_swiginit(self, _QuantLib.new_ActualActual(*args))
    __swig_destroy__ = _QuantLib.delete_ActualActual

# Register ActualActual in _QuantLib:
_QuantLib.ActualActual_swigregister(ActualActual)

class OneDayCounter(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.OneDayCounter_swiginit(self, _QuantLib.new_OneDayCounter())
    __swig_destroy__ = _QuantLib.delete_OneDayCounter

# Register OneDayCounter in _QuantLib:
_QuantLib.OneDayCounter_swigregister(OneDayCounter)

class SimpleDayCounter(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SimpleDayCounter_swiginit(self, _QuantLib.new_SimpleDayCounter())
    __swig_destroy__ = _QuantLib.delete_SimpleDayCounter

# Register SimpleDayCounter in _QuantLib:
_QuantLib.SimpleDayCounter_swigregister(SimpleDayCounter)

class Business252(DayCounter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Business252_swiginit(self, _QuantLib.new_Business252(*args))
    __swig_destroy__ = _QuantLib.delete_Business252

# Register Business252 in _QuantLib:
_QuantLib.Business252_swigregister(Business252)

Simple = _QuantLib.Simple
Compounded = _QuantLib.Compounded
Continuous = _QuantLib.Continuous
SimpleThenCompounded = _QuantLib.SimpleThenCompounded
CompoundedThenSimple = _QuantLib.CompoundedThenSimple
class InterestRate(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InterestRate_swiginit(self, _QuantLib.new_InterestRate(*args))

    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)

    @staticmethod
    def impliedRate(*args):
        return _QuantLib.InterestRate_impliedRate(*args)

    def equivalentRate(self, *args):
        return _QuantLib.InterestRate_equivalentRate(self, *args)

    def __str__(self):
        return _QuantLib.InterestRate___str__(self)
    __swig_destroy__ = _QuantLib.delete_InterestRate

# Register InterestRate in _QuantLib:
_QuantLib.InterestRate_swigregister(InterestRate)

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

class InterestRateVector(object):
    thisown = 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.InterestRateVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.InterestRateVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.InterestRateVector___bool__(self)

    def __len__(self):
        return _QuantLib.InterestRateVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.InterestRateVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.InterestRateVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.InterestRateVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.InterestRateVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.InterestRateVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.InterestRateVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.InterestRateVector_pop(self)

    def append(self, x):
        return _QuantLib.InterestRateVector_append(self, x)

    def empty(self):
        return _QuantLib.InterestRateVector_empty(self)

    def size(self):
        return _QuantLib.InterestRateVector_size(self)

    def swap(self, v):
        return _QuantLib.InterestRateVector_swap(self, v)

    def begin(self):
        return _QuantLib.InterestRateVector_begin(self)

    def end(self):
        return _QuantLib.InterestRateVector_end(self)

    def rbegin(self):
        return _QuantLib.InterestRateVector_rbegin(self)

    def rend(self):
        return _QuantLib.InterestRateVector_rend(self)

    def clear(self):
        return _QuantLib.InterestRateVector_clear(self)

    def get_allocator(self):
        return _QuantLib.InterestRateVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.InterestRateVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.InterestRateVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.InterestRateVector_swiginit(self, _QuantLib.new_InterestRateVector(*args))

    def push_back(self, x):
        return _QuantLib.InterestRateVector_push_back(self, x)

    def front(self):
        return _QuantLib.InterestRateVector_front(self)

    def back(self):
        return _QuantLib.InterestRateVector_back(self)

    def assign(self, n, x):
        return _QuantLib.InterestRateVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.InterestRateVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.InterestRateVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.InterestRateVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.InterestRateVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_InterestRateVector

# Register InterestRateVector in _QuantLib:
_QuantLib.InterestRateVector_swigregister(InterestRateVector)

class Rounding(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Rounding_swiginit(self, _QuantLib.new_Rounding())

    def __call__(self, value):
        return _QuantLib.Rounding___call__(self, value)
    __swig_destroy__ = _QuantLib.delete_Rounding

# Register Rounding in _QuantLib:
_QuantLib.Rounding_swigregister(Rounding)

class UpRounding(Rounding):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        _QuantLib.UpRounding_swiginit(self, _QuantLib.new_UpRounding(precision, digit))
    __swig_destroy__ = _QuantLib.delete_UpRounding

# Register UpRounding in _QuantLib:
_QuantLib.UpRounding_swigregister(UpRounding)

class DownRounding(Rounding):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        _QuantLib.DownRounding_swiginit(self, _QuantLib.new_DownRounding(precision, digit))
    __swig_destroy__ = _QuantLib.delete_DownRounding

# Register DownRounding in _QuantLib:
_QuantLib.DownRounding_swigregister(DownRounding)

class ClosestRounding(Rounding):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        _QuantLib.ClosestRounding_swiginit(self, _QuantLib.new_ClosestRounding(precision, digit))
    __swig_destroy__ = _QuantLib.delete_ClosestRounding

# Register ClosestRounding in _QuantLib:
_QuantLib.ClosestRounding_swigregister(ClosestRounding)

class CeilingTruncation(Rounding):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        _QuantLib.CeilingTruncation_swiginit(self, _QuantLib.new_CeilingTruncation(precision, digit))
    __swig_destroy__ = _QuantLib.delete_CeilingTruncation

# Register CeilingTruncation in _QuantLib:
_QuantLib.CeilingTruncation_swigregister(CeilingTruncation)

class FloorTruncation(Rounding):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        _QuantLib.FloorTruncation_swiginit(self, _QuantLib.new_FloorTruncation(precision, digit))
    __swig_destroy__ = _QuantLib.delete_FloorTruncation

# Register FloorTruncation in _QuantLib:
_QuantLib.FloorTruncation_swigregister(FloorTruncation)

class Currency(object):
    thisown = 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 empty(self):
        return _QuantLib.Currency_empty(self)

    def triangulationCurrency(self):
        return _QuantLib.Currency_triangulationCurrency(self)

    def __str__(self):
        return _QuantLib.Currency___str__(self)

    def __eq__(self, other):
        return _QuantLib.Currency___eq__(self, other)

    def __ne__(self, other):
        return _QuantLib.Currency___ne__(self, other)

    def __mul__(self, x):
        return _QuantLib.Currency___mul__(self, x)

    def __rmul__(self, x):
        return _QuantLib.Currency___rmul__(self, x)

    def __nonzero__(self):
        return _QuantLib.Currency___nonzero__(self)

    def __bool__(self):
        return _QuantLib.Currency___bool__(self)

    def __hash__(self):
        return hash(self.name())


    def __init__(self):
        _QuantLib.Currency_swiginit(self, _QuantLib.new_Currency())
    __swig_destroy__ = _QuantLib.delete_Currency

# Register Currency in _QuantLib:
_QuantLib.Currency_swigregister(Currency)

class ARSCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ARSCurrency_swiginit(self, _QuantLib.new_ARSCurrency())
    __swig_destroy__ = _QuantLib.delete_ARSCurrency

# Register ARSCurrency in _QuantLib:
_QuantLib.ARSCurrency_swigregister(ARSCurrency)

class ATSCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ATSCurrency_swiginit(self, _QuantLib.new_ATSCurrency())
    __swig_destroy__ = _QuantLib.delete_ATSCurrency

# Register ATSCurrency in _QuantLib:
_QuantLib.ATSCurrency_swigregister(ATSCurrency)

class AUDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.AUDCurrency_swiginit(self, _QuantLib.new_AUDCurrency())
    __swig_destroy__ = _QuantLib.delete_AUDCurrency

# Register AUDCurrency in _QuantLib:
_QuantLib.AUDCurrency_swigregister(AUDCurrency)

class BDTCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BDTCurrency_swiginit(self, _QuantLib.new_BDTCurrency())
    __swig_destroy__ = _QuantLib.delete_BDTCurrency

# Register BDTCurrency in _QuantLib:
_QuantLib.BDTCurrency_swigregister(BDTCurrency)

class BEFCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BEFCurrency_swiginit(self, _QuantLib.new_BEFCurrency())
    __swig_destroy__ = _QuantLib.delete_BEFCurrency

# Register BEFCurrency in _QuantLib:
_QuantLib.BEFCurrency_swigregister(BEFCurrency)

class BGLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BGLCurrency_swiginit(self, _QuantLib.new_BGLCurrency())
    __swig_destroy__ = _QuantLib.delete_BGLCurrency

# Register BGLCurrency in _QuantLib:
_QuantLib.BGLCurrency_swigregister(BGLCurrency)

class BRLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BRLCurrency_swiginit(self, _QuantLib.new_BRLCurrency())
    __swig_destroy__ = _QuantLib.delete_BRLCurrency

# Register BRLCurrency in _QuantLib:
_QuantLib.BRLCurrency_swigregister(BRLCurrency)

class BYRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BYRCurrency_swiginit(self, _QuantLib.new_BYRCurrency())
    __swig_destroy__ = _QuantLib.delete_BYRCurrency

# Register BYRCurrency in _QuantLib:
_QuantLib.BYRCurrency_swigregister(BYRCurrency)

class CADCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CADCurrency_swiginit(self, _QuantLib.new_CADCurrency())
    __swig_destroy__ = _QuantLib.delete_CADCurrency

# Register CADCurrency in _QuantLib:
_QuantLib.CADCurrency_swigregister(CADCurrency)

class CHFCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CHFCurrency_swiginit(self, _QuantLib.new_CHFCurrency())
    __swig_destroy__ = _QuantLib.delete_CHFCurrency

# Register CHFCurrency in _QuantLib:
_QuantLib.CHFCurrency_swigregister(CHFCurrency)

class CLPCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CLPCurrency_swiginit(self, _QuantLib.new_CLPCurrency())
    __swig_destroy__ = _QuantLib.delete_CLPCurrency

# Register CLPCurrency in _QuantLib:
_QuantLib.CLPCurrency_swigregister(CLPCurrency)

class CNYCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CNYCurrency_swiginit(self, _QuantLib.new_CNYCurrency())
    __swig_destroy__ = _QuantLib.delete_CNYCurrency

# Register CNYCurrency in _QuantLib:
_QuantLib.CNYCurrency_swigregister(CNYCurrency)

class COPCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.COPCurrency_swiginit(self, _QuantLib.new_COPCurrency())
    __swig_destroy__ = _QuantLib.delete_COPCurrency

# Register COPCurrency in _QuantLib:
_QuantLib.COPCurrency_swigregister(COPCurrency)

class CYPCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CYPCurrency_swiginit(self, _QuantLib.new_CYPCurrency())
    __swig_destroy__ = _QuantLib.delete_CYPCurrency

# Register CYPCurrency in _QuantLib:
_QuantLib.CYPCurrency_swigregister(CYPCurrency)

class CZKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CZKCurrency_swiginit(self, _QuantLib.new_CZKCurrency())
    __swig_destroy__ = _QuantLib.delete_CZKCurrency

# Register CZKCurrency in _QuantLib:
_QuantLib.CZKCurrency_swigregister(CZKCurrency)

class DEMCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.DEMCurrency_swiginit(self, _QuantLib.new_DEMCurrency())
    __swig_destroy__ = _QuantLib.delete_DEMCurrency

# Register DEMCurrency in _QuantLib:
_QuantLib.DEMCurrency_swigregister(DEMCurrency)

class DKKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.DKKCurrency_swiginit(self, _QuantLib.new_DKKCurrency())
    __swig_destroy__ = _QuantLib.delete_DKKCurrency

# Register DKKCurrency in _QuantLib:
_QuantLib.DKKCurrency_swigregister(DKKCurrency)

class EEKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.EEKCurrency_swiginit(self, _QuantLib.new_EEKCurrency())
    __swig_destroy__ = _QuantLib.delete_EEKCurrency

# Register EEKCurrency in _QuantLib:
_QuantLib.EEKCurrency_swigregister(EEKCurrency)

class ESPCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ESPCurrency_swiginit(self, _QuantLib.new_ESPCurrency())
    __swig_destroy__ = _QuantLib.delete_ESPCurrency

# Register ESPCurrency in _QuantLib:
_QuantLib.ESPCurrency_swigregister(ESPCurrency)

class EURCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.EURCurrency_swiginit(self, _QuantLib.new_EURCurrency())
    __swig_destroy__ = _QuantLib.delete_EURCurrency

# Register EURCurrency in _QuantLib:
_QuantLib.EURCurrency_swigregister(EURCurrency)

class FIMCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.FIMCurrency_swiginit(self, _QuantLib.new_FIMCurrency())
    __swig_destroy__ = _QuantLib.delete_FIMCurrency

# Register FIMCurrency in _QuantLib:
_QuantLib.FIMCurrency_swigregister(FIMCurrency)

class FRFCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.FRFCurrency_swiginit(self, _QuantLib.new_FRFCurrency())
    __swig_destroy__ = _QuantLib.delete_FRFCurrency

# Register FRFCurrency in _QuantLib:
_QuantLib.FRFCurrency_swigregister(FRFCurrency)

class GBPCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.GBPCurrency_swiginit(self, _QuantLib.new_GBPCurrency())
    __swig_destroy__ = _QuantLib.delete_GBPCurrency

# Register GBPCurrency in _QuantLib:
_QuantLib.GBPCurrency_swigregister(GBPCurrency)

class GRDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.GRDCurrency_swiginit(self, _QuantLib.new_GRDCurrency())
    __swig_destroy__ = _QuantLib.delete_GRDCurrency

# Register GRDCurrency in _QuantLib:
_QuantLib.GRDCurrency_swigregister(GRDCurrency)

class HKDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.HKDCurrency_swiginit(self, _QuantLib.new_HKDCurrency())
    __swig_destroy__ = _QuantLib.delete_HKDCurrency

# Register HKDCurrency in _QuantLib:
_QuantLib.HKDCurrency_swigregister(HKDCurrency)

class HUFCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.HUFCurrency_swiginit(self, _QuantLib.new_HUFCurrency())
    __swig_destroy__ = _QuantLib.delete_HUFCurrency

# Register HUFCurrency in _QuantLib:
_QuantLib.HUFCurrency_swigregister(HUFCurrency)

class IEPCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.IEPCurrency_swiginit(self, _QuantLib.new_IEPCurrency())
    __swig_destroy__ = _QuantLib.delete_IEPCurrency

# Register IEPCurrency in _QuantLib:
_QuantLib.IEPCurrency_swigregister(IEPCurrency)

class IDRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.IDRCurrency_swiginit(self, _QuantLib.new_IDRCurrency())
    __swig_destroy__ = _QuantLib.delete_IDRCurrency

# Register IDRCurrency in _QuantLib:
_QuantLib.IDRCurrency_swigregister(IDRCurrency)

class ILSCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ILSCurrency_swiginit(self, _QuantLib.new_ILSCurrency())
    __swig_destroy__ = _QuantLib.delete_ILSCurrency

# Register ILSCurrency in _QuantLib:
_QuantLib.ILSCurrency_swigregister(ILSCurrency)

class INRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.INRCurrency_swiginit(self, _QuantLib.new_INRCurrency())
    __swig_destroy__ = _QuantLib.delete_INRCurrency

# Register INRCurrency in _QuantLib:
_QuantLib.INRCurrency_swigregister(INRCurrency)

class IQDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.IQDCurrency_swiginit(self, _QuantLib.new_IQDCurrency())
    __swig_destroy__ = _QuantLib.delete_IQDCurrency

# Register IQDCurrency in _QuantLib:
_QuantLib.IQDCurrency_swigregister(IQDCurrency)

class IRRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.IRRCurrency_swiginit(self, _QuantLib.new_IRRCurrency())
    __swig_destroy__ = _QuantLib.delete_IRRCurrency

# Register IRRCurrency in _QuantLib:
_QuantLib.IRRCurrency_swigregister(IRRCurrency)

class ISKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ISKCurrency_swiginit(self, _QuantLib.new_ISKCurrency())
    __swig_destroy__ = _QuantLib.delete_ISKCurrency

# Register ISKCurrency in _QuantLib:
_QuantLib.ISKCurrency_swigregister(ISKCurrency)

class ITLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ITLCurrency_swiginit(self, _QuantLib.new_ITLCurrency())
    __swig_destroy__ = _QuantLib.delete_ITLCurrency

# Register ITLCurrency in _QuantLib:
_QuantLib.ITLCurrency_swigregister(ITLCurrency)

class JPYCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.JPYCurrency_swiginit(self, _QuantLib.new_JPYCurrency())
    __swig_destroy__ = _QuantLib.delete_JPYCurrency

# Register JPYCurrency in _QuantLib:
_QuantLib.JPYCurrency_swigregister(JPYCurrency)

class KRWCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.KRWCurrency_swiginit(self, _QuantLib.new_KRWCurrency())
    __swig_destroy__ = _QuantLib.delete_KRWCurrency

# Register KRWCurrency in _QuantLib:
_QuantLib.KRWCurrency_swigregister(KRWCurrency)

class KWDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.KWDCurrency_swiginit(self, _QuantLib.new_KWDCurrency())
    __swig_destroy__ = _QuantLib.delete_KWDCurrency

# Register KWDCurrency in _QuantLib:
_QuantLib.KWDCurrency_swigregister(KWDCurrency)

class LTLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.LTLCurrency_swiginit(self, _QuantLib.new_LTLCurrency())
    __swig_destroy__ = _QuantLib.delete_LTLCurrency

# Register LTLCurrency in _QuantLib:
_QuantLib.LTLCurrency_swigregister(LTLCurrency)

class LUFCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.LUFCurrency_swiginit(self, _QuantLib.new_LUFCurrency())
    __swig_destroy__ = _QuantLib.delete_LUFCurrency

# Register LUFCurrency in _QuantLib:
_QuantLib.LUFCurrency_swigregister(LUFCurrency)

class LVLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.LVLCurrency_swiginit(self, _QuantLib.new_LVLCurrency())
    __swig_destroy__ = _QuantLib.delete_LVLCurrency

# Register LVLCurrency in _QuantLib:
_QuantLib.LVLCurrency_swigregister(LVLCurrency)

class MTLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.MTLCurrency_swiginit(self, _QuantLib.new_MTLCurrency())
    __swig_destroy__ = _QuantLib.delete_MTLCurrency

# Register MTLCurrency in _QuantLib:
_QuantLib.MTLCurrency_swigregister(MTLCurrency)

class MXNCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.MXNCurrency_swiginit(self, _QuantLib.new_MXNCurrency())
    __swig_destroy__ = _QuantLib.delete_MXNCurrency

# Register MXNCurrency in _QuantLib:
_QuantLib.MXNCurrency_swigregister(MXNCurrency)

class MYRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.MYRCurrency_swiginit(self, _QuantLib.new_MYRCurrency())
    __swig_destroy__ = _QuantLib.delete_MYRCurrency

# Register MYRCurrency in _QuantLib:
_QuantLib.MYRCurrency_swigregister(MYRCurrency)

class NLGCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NLGCurrency_swiginit(self, _QuantLib.new_NLGCurrency())
    __swig_destroy__ = _QuantLib.delete_NLGCurrency

# Register NLGCurrency in _QuantLib:
_QuantLib.NLGCurrency_swigregister(NLGCurrency)

class NOKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NOKCurrency_swiginit(self, _QuantLib.new_NOKCurrency())
    __swig_destroy__ = _QuantLib.delete_NOKCurrency

# Register NOKCurrency in _QuantLib:
_QuantLib.NOKCurrency_swigregister(NOKCurrency)

class NPRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NPRCurrency_swiginit(self, _QuantLib.new_NPRCurrency())
    __swig_destroy__ = _QuantLib.delete_NPRCurrency

# Register NPRCurrency in _QuantLib:
_QuantLib.NPRCurrency_swigregister(NPRCurrency)

class NZDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NZDCurrency_swiginit(self, _QuantLib.new_NZDCurrency())
    __swig_destroy__ = _QuantLib.delete_NZDCurrency

# Register NZDCurrency in _QuantLib:
_QuantLib.NZDCurrency_swigregister(NZDCurrency)

class PEHCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PEHCurrency_swiginit(self, _QuantLib.new_PEHCurrency())
    __swig_destroy__ = _QuantLib.delete_PEHCurrency

# Register PEHCurrency in _QuantLib:
_QuantLib.PEHCurrency_swigregister(PEHCurrency)

class PEICurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PEICurrency_swiginit(self, _QuantLib.new_PEICurrency())
    __swig_destroy__ = _QuantLib.delete_PEICurrency

# Register PEICurrency in _QuantLib:
_QuantLib.PEICurrency_swigregister(PEICurrency)

class PENCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PENCurrency_swiginit(self, _QuantLib.new_PENCurrency())
    __swig_destroy__ = _QuantLib.delete_PENCurrency

# Register PENCurrency in _QuantLib:
_QuantLib.PENCurrency_swigregister(PENCurrency)

class PKRCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PKRCurrency_swiginit(self, _QuantLib.new_PKRCurrency())
    __swig_destroy__ = _QuantLib.delete_PKRCurrency

# Register PKRCurrency in _QuantLib:
_QuantLib.PKRCurrency_swigregister(PKRCurrency)

class PLNCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PLNCurrency_swiginit(self, _QuantLib.new_PLNCurrency())
    __swig_destroy__ = _QuantLib.delete_PLNCurrency

# Register PLNCurrency in _QuantLib:
_QuantLib.PLNCurrency_swigregister(PLNCurrency)

class PTECurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PTECurrency_swiginit(self, _QuantLib.new_PTECurrency())
    __swig_destroy__ = _QuantLib.delete_PTECurrency

# Register PTECurrency in _QuantLib:
_QuantLib.PTECurrency_swigregister(PTECurrency)

class ROLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ROLCurrency_swiginit(self, _QuantLib.new_ROLCurrency())
    __swig_destroy__ = _QuantLib.delete_ROLCurrency

# Register ROLCurrency in _QuantLib:
_QuantLib.ROLCurrency_swigregister(ROLCurrency)

class RONCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.RONCurrency_swiginit(self, _QuantLib.new_RONCurrency())
    __swig_destroy__ = _QuantLib.delete_RONCurrency

# Register RONCurrency in _QuantLib:
_QuantLib.RONCurrency_swigregister(RONCurrency)

class RUBCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.RUBCurrency_swiginit(self, _QuantLib.new_RUBCurrency())
    __swig_destroy__ = _QuantLib.delete_RUBCurrency

# Register RUBCurrency in _QuantLib:
_QuantLib.RUBCurrency_swigregister(RUBCurrency)

class SARCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SARCurrency_swiginit(self, _QuantLib.new_SARCurrency())
    __swig_destroy__ = _QuantLib.delete_SARCurrency

# Register SARCurrency in _QuantLib:
_QuantLib.SARCurrency_swigregister(SARCurrency)

class SEKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SEKCurrency_swiginit(self, _QuantLib.new_SEKCurrency())
    __swig_destroy__ = _QuantLib.delete_SEKCurrency

# Register SEKCurrency in _QuantLib:
_QuantLib.SEKCurrency_swigregister(SEKCurrency)

class SGDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SGDCurrency_swiginit(self, _QuantLib.new_SGDCurrency())
    __swig_destroy__ = _QuantLib.delete_SGDCurrency

# Register SGDCurrency in _QuantLib:
_QuantLib.SGDCurrency_swigregister(SGDCurrency)

class SITCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SITCurrency_swiginit(self, _QuantLib.new_SITCurrency())
    __swig_destroy__ = _QuantLib.delete_SITCurrency

# Register SITCurrency in _QuantLib:
_QuantLib.SITCurrency_swigregister(SITCurrency)

class SKKCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SKKCurrency_swiginit(self, _QuantLib.new_SKKCurrency())
    __swig_destroy__ = _QuantLib.delete_SKKCurrency

# Register SKKCurrency in _QuantLib:
_QuantLib.SKKCurrency_swigregister(SKKCurrency)

class THBCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.THBCurrency_swiginit(self, _QuantLib.new_THBCurrency())
    __swig_destroy__ = _QuantLib.delete_THBCurrency

# Register THBCurrency in _QuantLib:
_QuantLib.THBCurrency_swigregister(THBCurrency)

class TRLCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.TRLCurrency_swiginit(self, _QuantLib.new_TRLCurrency())
    __swig_destroy__ = _QuantLib.delete_TRLCurrency

# Register TRLCurrency in _QuantLib:
_QuantLib.TRLCurrency_swigregister(TRLCurrency)

class TRYCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.TRYCurrency_swiginit(self, _QuantLib.new_TRYCurrency())
    __swig_destroy__ = _QuantLib.delete_TRYCurrency

# Register TRYCurrency in _QuantLib:
_QuantLib.TRYCurrency_swigregister(TRYCurrency)

class TTDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.TTDCurrency_swiginit(self, _QuantLib.new_TTDCurrency())
    __swig_destroy__ = _QuantLib.delete_TTDCurrency

# Register TTDCurrency in _QuantLib:
_QuantLib.TTDCurrency_swigregister(TTDCurrency)

class TWDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.TWDCurrency_swiginit(self, _QuantLib.new_TWDCurrency())
    __swig_destroy__ = _QuantLib.delete_TWDCurrency

# Register TWDCurrency in _QuantLib:
_QuantLib.TWDCurrency_swigregister(TWDCurrency)

class USDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.USDCurrency_swiginit(self, _QuantLib.new_USDCurrency())
    __swig_destroy__ = _QuantLib.delete_USDCurrency

# Register USDCurrency in _QuantLib:
_QuantLib.USDCurrency_swigregister(USDCurrency)

class VEBCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.VEBCurrency_swiginit(self, _QuantLib.new_VEBCurrency())
    __swig_destroy__ = _QuantLib.delete_VEBCurrency

# Register VEBCurrency in _QuantLib:
_QuantLib.VEBCurrency_swigregister(VEBCurrency)

class VNDCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.VNDCurrency_swiginit(self, _QuantLib.new_VNDCurrency())
    __swig_destroy__ = _QuantLib.delete_VNDCurrency

# Register VNDCurrency in _QuantLib:
_QuantLib.VNDCurrency_swigregister(VNDCurrency)

class ZARCurrency(Currency):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ZARCurrency_swiginit(self, _QuantLib.new_ZARCurrency())
    __swig_destroy__ = _QuantLib.delete_ZARCurrency

# Register ZARCurrency in _QuantLib:
_QuantLib.ZARCurrency_swigregister(ZARCurrency)

class Brent(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.Brent_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.Brent_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.Brent_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.Brent_solve(self, *args)

    def __init__(self):
        _QuantLib.Brent_swiginit(self, _QuantLib.new_Brent())
    __swig_destroy__ = _QuantLib.delete_Brent

# Register Brent in _QuantLib:
_QuantLib.Brent_swigregister(Brent)

class Bisection(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.Bisection_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.Bisection_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.Bisection_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.Bisection_solve(self, *args)

    def __init__(self):
        _QuantLib.Bisection_swiginit(self, _QuantLib.new_Bisection())
    __swig_destroy__ = _QuantLib.delete_Bisection

# Register Bisection in _QuantLib:
_QuantLib.Bisection_swigregister(Bisection)

class FalsePosition(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.FalsePosition_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.FalsePosition_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.FalsePosition_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.FalsePosition_solve(self, *args)

    def __init__(self):
        _QuantLib.FalsePosition_swiginit(self, _QuantLib.new_FalsePosition())
    __swig_destroy__ = _QuantLib.delete_FalsePosition

# Register FalsePosition in _QuantLib:
_QuantLib.FalsePosition_swigregister(FalsePosition)

class Ridder(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.Ridder_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.Ridder_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.Ridder_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.Ridder_solve(self, *args)

    def __init__(self):
        _QuantLib.Ridder_swiginit(self, _QuantLib.new_Ridder())
    __swig_destroy__ = _QuantLib.delete_Ridder

# Register Ridder in _QuantLib:
_QuantLib.Ridder_swigregister(Ridder)

class Secant(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.Secant_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.Secant_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.Secant_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.Secant_solve(self, *args)

    def __init__(self):
        _QuantLib.Secant_swiginit(self, _QuantLib.new_Secant())
    __swig_destroy__ = _QuantLib.delete_Secant

# Register Secant in _QuantLib:
_QuantLib.Secant_swigregister(Secant)

class Newton(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.Newton_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.Newton_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.Newton_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.Newton_solve(self, *args)

    def __init__(self):
        _QuantLib.Newton_swiginit(self, _QuantLib.new_Newton())
    __swig_destroy__ = _QuantLib.delete_Newton

# Register Newton in _QuantLib:
_QuantLib.Newton_swigregister(Newton)

class NewtonSafe(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def setMaxEvaluations(self, evaluations):
        return _QuantLib.NewtonSafe_setMaxEvaluations(self, evaluations)

    def setLowerBound(self, lowerBound):
        return _QuantLib.NewtonSafe_setLowerBound(self, lowerBound)

    def setUpperBound(self, upperBound):
        return _QuantLib.NewtonSafe_setUpperBound(self, upperBound)

    def solve(self, *args):
        return _QuantLib.NewtonSafe_solve(self, *args)

    def __init__(self):
        _QuantLib.NewtonSafe_swiginit(self, _QuantLib.new_NewtonSafe())
    __swig_destroy__ = _QuantLib.delete_NewtonSafe

# Register NewtonSafe in _QuantLib:
_QuantLib.NewtonSafe_swigregister(NewtonSafe)

class Constraint(object):
    thisown = 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

# Register Constraint in _QuantLib:
_QuantLib.Constraint_swigregister(Constraint)

class BoundaryConstraint(Constraint):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lower, upper):
        _QuantLib.BoundaryConstraint_swiginit(self, _QuantLib.new_BoundaryConstraint(lower, upper))
    __swig_destroy__ = _QuantLib.delete_BoundaryConstraint

# Register BoundaryConstraint in _QuantLib:
_QuantLib.BoundaryConstraint_swigregister(BoundaryConstraint)

class NoConstraint(Constraint):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NoConstraint_swiginit(self, _QuantLib.new_NoConstraint())
    __swig_destroy__ = _QuantLib.delete_NoConstraint

# Register NoConstraint in _QuantLib:
_QuantLib.NoConstraint_swigregister(NoConstraint)

class PositiveConstraint(Constraint):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.PositiveConstraint_swiginit(self, _QuantLib.new_PositiveConstraint())
    __swig_destroy__ = _QuantLib.delete_PositiveConstraint

# Register PositiveConstraint in _QuantLib:
_QuantLib.PositiveConstraint_swigregister(PositiveConstraint)

class CompositeConstraint(Constraint):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, c1, c2):
        _QuantLib.CompositeConstraint_swiginit(self, _QuantLib.new_CompositeConstraint(c1, c2))
    __swig_destroy__ = _QuantLib.delete_CompositeConstraint

# Register CompositeConstraint in _QuantLib:
_QuantLib.CompositeConstraint_swigregister(CompositeConstraint)

class NonhomogeneousBoundaryConstraint(Constraint):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, l, u):
        _QuantLib.NonhomogeneousBoundaryConstraint_swiginit(self, _QuantLib.new_NonhomogeneousBoundaryConstraint(l, u))
    __swig_destroy__ = _QuantLib.delete_NonhomogeneousBoundaryConstraint

# Register NonhomogeneousBoundaryConstraint in _QuantLib:
_QuantLib.NonhomogeneousBoundaryConstraint_swigregister(NonhomogeneousBoundaryConstraint)

class EndCriteria(object):
    thisown = 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, maxIteration, maxStationaryStateIterations, rootEpsilon, functionEpsilon, gradientNormEpsilon):
        _QuantLib.EndCriteria_swiginit(self, _QuantLib.new_EndCriteria(maxIteration, maxStationaryStateIterations, rootEpsilon, functionEpsilon, gradientNormEpsilon))

    def __call__(self, iteration, statState, positiveOptimization, fold, normgold, fnew, normgnewx, ecType):
        return _QuantLib.EndCriteria___call__(self, iteration, statState, positiveOptimization, fold, normgold, fnew, normgnewx, ecType)
    __swig_destroy__ = _QuantLib.delete_EndCriteria

# Register EndCriteria in _QuantLib:
_QuantLib.EndCriteria_swigregister(EndCriteria)

class OptimizationMethod(object):
    thisown = 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

# Register OptimizationMethod in _QuantLib:
_QuantLib.OptimizationMethod_swigregister(OptimizationMethod)

class ConjugateGradient(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ConjugateGradient_swiginit(self, _QuantLib.new_ConjugateGradient())
    __swig_destroy__ = _QuantLib.delete_ConjugateGradient

# Register ConjugateGradient in _QuantLib:
_QuantLib.ConjugateGradient_swigregister(ConjugateGradient)

class Simplex(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lambda_parameter):
        _QuantLib.Simplex_swiginit(self, _QuantLib.new_Simplex(lambda_parameter))

    def getLambda(self):
        return _QuantLib.Simplex_getLambda(self)
    __swig_destroy__ = _QuantLib.delete_Simplex

# Register Simplex in _QuantLib:
_QuantLib.Simplex_swigregister(Simplex)

class SteepestDescent(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SteepestDescent_swiginit(self, _QuantLib.new_SteepestDescent())
    __swig_destroy__ = _QuantLib.delete_SteepestDescent

# Register SteepestDescent in _QuantLib:
_QuantLib.SteepestDescent_swigregister(SteepestDescent)

class BFGS(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BFGS_swiginit(self, _QuantLib.new_BFGS())
    __swig_destroy__ = _QuantLib.delete_BFGS

# Register BFGS in _QuantLib:
_QuantLib.BFGS_swigregister(BFGS)

class LevenbergMarquardt(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, epsfcn=1.0e-8, xtol=1.0e-8, gtol=1.0e-8, useCostFunctionsJacobian=False):
        _QuantLib.LevenbergMarquardt_swiginit(self, _QuantLib.new_LevenbergMarquardt(epsfcn, xtol, gtol, useCostFunctionsJacobian))
    __swig_destroy__ = _QuantLib.delete_LevenbergMarquardt

# Register LevenbergMarquardt in _QuantLib:
_QuantLib.LevenbergMarquardt_swigregister(LevenbergMarquardt)

class DifferentialEvolution(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.DifferentialEvolution_swiginit(self, _QuantLib.new_DifferentialEvolution())
    __swig_destroy__ = _QuantLib.delete_DifferentialEvolution

# Register DifferentialEvolution in _QuantLib:
_QuantLib.DifferentialEvolution_swigregister(DifferentialEvolution)

class SamplerGaussian(object):
    thisown = 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):
        _QuantLib.SamplerGaussian_swiginit(self, _QuantLib.new_SamplerGaussian(seed))
    __swig_destroy__ = _QuantLib.delete_SamplerGaussian

# Register SamplerGaussian in _QuantLib:
_QuantLib.SamplerGaussian_swigregister(SamplerGaussian)

class SamplerLogNormal(object):
    thisown = 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):
        _QuantLib.SamplerLogNormal_swiginit(self, _QuantLib.new_SamplerLogNormal(seed))
    __swig_destroy__ = _QuantLib.delete_SamplerLogNormal

# Register SamplerLogNormal in _QuantLib:
_QuantLib.SamplerLogNormal_swigregister(SamplerLogNormal)

class SamplerMirrorGaussian(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lower, upper, seed=0):
        _QuantLib.SamplerMirrorGaussian_swiginit(self, _QuantLib.new_SamplerMirrorGaussian(lower, upper, seed))
    __swig_destroy__ = _QuantLib.delete_SamplerMirrorGaussian

# Register SamplerMirrorGaussian in _QuantLib:
_QuantLib.SamplerMirrorGaussian_swigregister(SamplerMirrorGaussian)

class ProbabilityBoltzmannDownhill(object):
    thisown = 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):
        _QuantLib.ProbabilityBoltzmannDownhill_swiginit(self, _QuantLib.new_ProbabilityBoltzmannDownhill(seed))
    __swig_destroy__ = _QuantLib.delete_ProbabilityBoltzmannDownhill

# Register ProbabilityBoltzmannDownhill in _QuantLib:
_QuantLib.ProbabilityBoltzmannDownhill_swigregister(ProbabilityBoltzmannDownhill)

class TemperatureExponential(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, initialTemp, dimension, power=0.95):
        _QuantLib.TemperatureExponential_swiginit(self, _QuantLib.new_TemperatureExponential(initialTemp, dimension, power))
    __swig_destroy__ = _QuantLib.delete_TemperatureExponential

# Register TemperatureExponential in _QuantLib:
_QuantLib.TemperatureExponential_swigregister(TemperatureExponential)

class ReannealingTrivial(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ReannealingTrivial_swiginit(self, _QuantLib.new_ReannealingTrivial())
    __swig_destroy__ = _QuantLib.delete_ReannealingTrivial

# Register ReannealingTrivial in _QuantLib:
_QuantLib.ReannealingTrivial_swigregister(ReannealingTrivial)

class GaussianSimulatedAnnealing(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoResetScheme = _QuantLib.GaussianSimulatedAnnealing_NoResetScheme
    ResetToBestPoint = _QuantLib.GaussianSimulatedAnnealing_ResetToBestPoint
    ResetToOrigin = _QuantLib.GaussianSimulatedAnnealing_ResetToOrigin

    def __init__(self, *args):
        _QuantLib.GaussianSimulatedAnnealing_swiginit(self, _QuantLib.new_GaussianSimulatedAnnealing(*args))
    __swig_destroy__ = _QuantLib.delete_GaussianSimulatedAnnealing

# Register GaussianSimulatedAnnealing in _QuantLib:
_QuantLib.GaussianSimulatedAnnealing_swigregister(GaussianSimulatedAnnealing)

class MirrorGaussianSimulatedAnnealing(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoResetScheme = _QuantLib.MirrorGaussianSimulatedAnnealing_NoResetScheme
    ResetToBestPoint = _QuantLib.MirrorGaussianSimulatedAnnealing_ResetToBestPoint
    ResetToOrigin = _QuantLib.MirrorGaussianSimulatedAnnealing_ResetToOrigin

    def __init__(self, *args):
        _QuantLib.MirrorGaussianSimulatedAnnealing_swiginit(self, _QuantLib.new_MirrorGaussianSimulatedAnnealing(*args))
    __swig_destroy__ = _QuantLib.delete_MirrorGaussianSimulatedAnnealing

# Register MirrorGaussianSimulatedAnnealing in _QuantLib:
_QuantLib.MirrorGaussianSimulatedAnnealing_swigregister(MirrorGaussianSimulatedAnnealing)

class LogNormalSimulatedAnnealing(OptimizationMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoResetScheme = _QuantLib.LogNormalSimulatedAnnealing_NoResetScheme
    ResetToBestPoint = _QuantLib.LogNormalSimulatedAnnealing_ResetToBestPoint
    ResetToOrigin = _QuantLib.LogNormalSimulatedAnnealing_ResetToOrigin

    def __init__(self, *args):
        _QuantLib.LogNormalSimulatedAnnealing_swiginit(self, _QuantLib.new_LogNormalSimulatedAnnealing(*args))
    __swig_destroy__ = _QuantLib.delete_LogNormalSimulatedAnnealing

# Register LogNormalSimulatedAnnealing in _QuantLib:
_QuantLib.LogNormalSimulatedAnnealing_swigregister(LogNormalSimulatedAnnealing)

class Optimizer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def solve(self, function, c, m, e, iv):
        return _QuantLib.Optimizer_solve(self, function, c, m, e, iv)

    def __init__(self):
        _QuantLib.Optimizer_swiginit(self, _QuantLib.new_Optimizer())
    __swig_destroy__ = _QuantLib.delete_Optimizer

# Register Optimizer in _QuantLib:
_QuantLib.Optimizer_swigregister(Optimizer)

class LinearInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.LinearInterpolation_swiginit(self, _QuantLib.new_LinearInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.LinearInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_LinearInterpolation

# Register LinearInterpolation in _QuantLib:
_QuantLib.LinearInterpolation_swigregister(LinearInterpolation)

class LogLinearInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.LogLinearInterpolation_swiginit(self, _QuantLib.new_LogLinearInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.LogLinearInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_LogLinearInterpolation

# Register LogLinearInterpolation in _QuantLib:
_QuantLib.LogLinearInterpolation_swigregister(LogLinearInterpolation)

class BackwardFlatInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.BackwardFlatInterpolation_swiginit(self, _QuantLib.new_BackwardFlatInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.BackwardFlatInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BackwardFlatInterpolation

# Register BackwardFlatInterpolation in _QuantLib:
_QuantLib.BackwardFlatInterpolation_swigregister(BackwardFlatInterpolation)

class ForwardFlatInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.ForwardFlatInterpolation_swiginit(self, _QuantLib.new_ForwardFlatInterpolation(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.ForwardFlatInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_ForwardFlatInterpolation

# Register ForwardFlatInterpolation in _QuantLib:
_QuantLib.ForwardFlatInterpolation_swigregister(ForwardFlatInterpolation)

class CubicNaturalSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.CubicNaturalSpline_swiginit(self, _QuantLib.new_CubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.CubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.CubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.CubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.CubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_CubicNaturalSpline

# Register CubicNaturalSpline in _QuantLib:
_QuantLib.CubicNaturalSpline_swigregister(CubicNaturalSpline)

class LogCubicNaturalSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.LogCubicNaturalSpline_swiginit(self, _QuantLib.new_LogCubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.LogCubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.LogCubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.LogCubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.LogCubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_LogCubicNaturalSpline

# Register LogCubicNaturalSpline in _QuantLib:
_QuantLib.LogCubicNaturalSpline_swigregister(LogCubicNaturalSpline)

class MonotonicCubicNaturalSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.MonotonicCubicNaturalSpline_swiginit(self, _QuantLib.new_MonotonicCubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.MonotonicCubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicCubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicCubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.MonotonicCubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicNaturalSpline

# Register MonotonicCubicNaturalSpline in _QuantLib:
_QuantLib.MonotonicCubicNaturalSpline_swigregister(MonotonicCubicNaturalSpline)

class MonotonicLogCubicNaturalSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.MonotonicLogCubicNaturalSpline_swiginit(self, _QuantLib.new_MonotonicLogCubicNaturalSpline(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.MonotonicLogCubicNaturalSpline___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicLogCubicNaturalSpline_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicLogCubicNaturalSpline_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.MonotonicLogCubicNaturalSpline_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubicNaturalSpline

# Register MonotonicLogCubicNaturalSpline in _QuantLib:
_QuantLib.MonotonicLogCubicNaturalSpline_swigregister(MonotonicLogCubicNaturalSpline)

class KrugerCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.KrugerCubic_swiginit(self, _QuantLib.new_KrugerCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.KrugerCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.KrugerCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.KrugerCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.KrugerCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_KrugerCubic

# Register KrugerCubic in _QuantLib:
_QuantLib.KrugerCubic_swigregister(KrugerCubic)

class KrugerLogCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.KrugerLogCubic_swiginit(self, _QuantLib.new_KrugerLogCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.KrugerLogCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.KrugerLogCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.KrugerLogCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.KrugerLogCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_KrugerLogCubic

# Register KrugerLogCubic in _QuantLib:
_QuantLib.KrugerLogCubic_swigregister(KrugerLogCubic)

class FritschButlandCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.FritschButlandCubic_swiginit(self, _QuantLib.new_FritschButlandCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.FritschButlandCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.FritschButlandCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.FritschButlandCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.FritschButlandCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_FritschButlandCubic

# Register FritschButlandCubic in _QuantLib:
_QuantLib.FritschButlandCubic_swigregister(FritschButlandCubic)

class FritschButlandLogCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.FritschButlandLogCubic_swiginit(self, _QuantLib.new_FritschButlandLogCubic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.FritschButlandLogCubic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.FritschButlandLogCubic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.FritschButlandLogCubic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.FritschButlandLogCubic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_FritschButlandLogCubic

# Register FritschButlandLogCubic in _QuantLib:
_QuantLib.FritschButlandLogCubic_swigregister(FritschButlandLogCubic)

class Parabolic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.Parabolic_swiginit(self, _QuantLib.new_Parabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.Parabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.Parabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.Parabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.Parabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_Parabolic

# Register Parabolic in _QuantLib:
_QuantLib.Parabolic_swigregister(Parabolic)

class LogParabolic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.LogParabolic_swiginit(self, _QuantLib.new_LogParabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.LogParabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.LogParabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.LogParabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.LogParabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_LogParabolic

# Register LogParabolic in _QuantLib:
_QuantLib.LogParabolic_swigregister(LogParabolic)

class MonotonicParabolic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.MonotonicParabolic_swiginit(self, _QuantLib.new_MonotonicParabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.MonotonicParabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicParabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicParabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.MonotonicParabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicParabolic

# Register MonotonicParabolic in _QuantLib:
_QuantLib.MonotonicParabolic_swigregister(MonotonicParabolic)

class MonotonicLogParabolic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y):
        _QuantLib.MonotonicLogParabolic_swiginit(self, _QuantLib.new_MonotonicLogParabolic(x, y))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.MonotonicLogParabolic___call__(self, x, allowExtrapolation)

    def derivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicLogParabolic_derivative(self, x, extrapolate)

    def secondDerivative(self, x, extrapolate=False):
        return _QuantLib.MonotonicLogParabolic_secondDerivative(self, x, extrapolate)

    def primitive(self, x, extrapolate=False):
        return _QuantLib.MonotonicLogParabolic_primitive(self, x, extrapolate)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogParabolic

# Register MonotonicLogParabolic in _QuantLib:
_QuantLib.MonotonicLogParabolic_swigregister(MonotonicLogParabolic)

class BilinearInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y, m):
        _QuantLib.BilinearInterpolation_swiginit(self, _QuantLib.new_BilinearInterpolation(x, y, m))

    def __call__(self, x, y, allowExtrapolation=False):
        return _QuantLib.BilinearInterpolation___call__(self, x, y, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BilinearInterpolation

# Register BilinearInterpolation in _QuantLib:
_QuantLib.BilinearInterpolation_swigregister(BilinearInterpolation)

class BicubicSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y, m):
        _QuantLib.BicubicSpline_swiginit(self, _QuantLib.new_BicubicSpline(x, y, m))

    def __call__(self, x, y, allowExtrapolation=False):
        return _QuantLib.BicubicSpline___call__(self, x, y, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BicubicSpline

# Register BicubicSpline in _QuantLib:
_QuantLib.BicubicSpline_swigregister(BicubicSpline)

class BackwardFlat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.BackwardFlat_swiginit(self, _QuantLib.new_BackwardFlat())
    __swig_destroy__ = _QuantLib.delete_BackwardFlat

# Register BackwardFlat in _QuantLib:
_QuantLib.BackwardFlat_swigregister(BackwardFlat)

class ForwardFlat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ForwardFlat_swiginit(self, _QuantLib.new_ForwardFlat())
    __swig_destroy__ = _QuantLib.delete_ForwardFlat

# Register ForwardFlat in _QuantLib:
_QuantLib.ForwardFlat_swigregister(ForwardFlat)

class Linear(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Linear_swiginit(self, _QuantLib.new_Linear())
    __swig_destroy__ = _QuantLib.delete_Linear

# Register Linear in _QuantLib:
_QuantLib.Linear_swigregister(Linear)

class LogLinear(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.LogLinear_swiginit(self, _QuantLib.new_LogLinear())
    __swig_destroy__ = _QuantLib.delete_LogLinear

# Register LogLinear in _QuantLib:
_QuantLib.LogLinear_swigregister(LogLinear)

class Cubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Cubic_swiginit(self, _QuantLib.new_Cubic())
    __swig_destroy__ = _QuantLib.delete_Cubic

# Register Cubic in _QuantLib:
_QuantLib.Cubic_swigregister(Cubic)

class Bicubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Bicubic_swiginit(self, _QuantLib.new_Bicubic())
    __swig_destroy__ = _QuantLib.delete_Bicubic

# Register Bicubic in _QuantLib:
_QuantLib.Bicubic_swigregister(Bicubic)

class MonotonicCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.MonotonicCubic_swiginit(self, _QuantLib.new_MonotonicCubic())
    __swig_destroy__ = _QuantLib.delete_MonotonicCubic

# Register MonotonicCubic in _QuantLib:
_QuantLib.MonotonicCubic_swigregister(MonotonicCubic)

class DefaultLogCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.DefaultLogCubic_swiginit(self, _QuantLib.new_DefaultLogCubic())
    __swig_destroy__ = _QuantLib.delete_DefaultLogCubic

# Register DefaultLogCubic in _QuantLib:
_QuantLib.DefaultLogCubic_swigregister(DefaultLogCubic)

class MonotonicLogCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.MonotonicLogCubic_swiginit(self, _QuantLib.new_MonotonicLogCubic())
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubic

# Register MonotonicLogCubic in _QuantLib:
_QuantLib.MonotonicLogCubic_swigregister(MonotonicLogCubic)

class SplineCubic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.SplineCubic_swiginit(self, _QuantLib.new_SplineCubic())
    __swig_destroy__ = _QuantLib.delete_SplineCubic

# Register SplineCubic in _QuantLib:
_QuantLib.SplineCubic_swigregister(SplineCubic)

class Kruger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Kruger_swiginit(self, _QuantLib.new_Kruger())
    __swig_destroy__ = _QuantLib.delete_Kruger

# Register Kruger in _QuantLib:
_QuantLib.Kruger_swigregister(Kruger)

class KrugerLog(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.KrugerLog_swiginit(self, _QuantLib.new_KrugerLog())
    __swig_destroy__ = _QuantLib.delete_KrugerLog

# Register KrugerLog in _QuantLib:
_QuantLib.KrugerLog_swigregister(KrugerLog)

class ConvexMonotone(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, quadraticity=0.3, monotonicity=0.7, forcePositive=True):
        _QuantLib.ConvexMonotone_swiginit(self, _QuantLib.new_ConvexMonotone(quadraticity, monotonicity, forcePositive))
    __swig_destroy__ = _QuantLib.delete_ConvexMonotone

# Register ConvexMonotone in _QuantLib:
_QuantLib.ConvexMonotone_swigregister(ConvexMonotone)

class SABRInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SABRInterpolation_swiginit(self, _QuantLib.new_SABRInterpolation(*args))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.SABRInterpolation___call__(self, x, allowExtrapolation)

    def alpha(self):
        return _QuantLib.SABRInterpolation_alpha(self)

    def beta(self):
        return _QuantLib.SABRInterpolation_beta(self)

    def rho(self):
        return _QuantLib.SABRInterpolation_rho(self)

    def nu(self):
        return _QuantLib.SABRInterpolation_nu(self)
    __swig_destroy__ = _QuantLib.delete_SABRInterpolation

# Register SABRInterpolation in _QuantLib:
_QuantLib.SABRInterpolation_swigregister(SABRInterpolation)

class RichardsonExtrapolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, *args):
        return _QuantLib.RichardsonExtrapolation___call__(self, *args)

    def __init__(self, *args):
        _QuantLib.RichardsonExtrapolation_swiginit(self, _QuantLib.new_RichardsonExtrapolation(*args))
    __swig_destroy__ = _QuantLib.delete_RichardsonExtrapolation

# Register RichardsonExtrapolation in _QuantLib:
_QuantLib.RichardsonExtrapolation_swigregister(RichardsonExtrapolation)

class ConvexMonotoneInterpolation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x, y, quadraticity=0.3, monotonicity=0.7, forcePositive=True):
        _QuantLib.ConvexMonotoneInterpolation_swiginit(self, _QuantLib.new_ConvexMonotoneInterpolation(x, y, quadraticity, monotonicity, forcePositive))

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.ConvexMonotoneInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_ConvexMonotoneInterpolation

# Register ConvexMonotoneInterpolation in _QuantLib:
_QuantLib.ConvexMonotoneInterpolation_swigregister(ConvexMonotoneInterpolation)

class TermStructure(Observable):
    thisown = 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 dayCounter(self):
        return _QuantLib.TermStructure_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.TermStructure_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.TermStructure_calendar(self)

    def referenceDate(self):
        return _QuantLib.TermStructure_referenceDate(self)

    def maxDate(self):
        return _QuantLib.TermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.TermStructure_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.TermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.TermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.TermStructure_allowsExtrapolation(self)
    __swig_destroy__ = _QuantLib.delete_TermStructure

# Register TermStructure in _QuantLib:
_QuantLib.TermStructure_swigregister(TermStructure)

class YieldTermStructure(TermStructure):
    thisown = 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 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)
    __swig_destroy__ = _QuantLib.delete_YieldTermStructure

# Register YieldTermStructure in _QuantLib:
_QuantLib.YieldTermStructure_swigregister(YieldTermStructure)

class YieldTermStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YieldTermStructureHandle_swiginit(self, _QuantLib.new_YieldTermStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.YieldTermStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.YieldTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.YieldTermStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.YieldTermStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.YieldTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YieldTermStructureHandle

    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 dayCounter(self):
        return _QuantLib.YieldTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.YieldTermStructureHandle_timeFromReference(self, date)

    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 enableExtrapolation(self):
        return _QuantLib.YieldTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YieldTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YieldTermStructureHandle_allowsExtrapolation(self)

# Register YieldTermStructureHandle in _QuantLib:
_QuantLib.YieldTermStructureHandle_swigregister(YieldTermStructureHandle)

class RelinkableYieldTermStructureHandle(YieldTermStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableYieldTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableYieldTermStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableYieldTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableYieldTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableYieldTermStructureHandle

# Register RelinkableYieldTermStructureHandle in _QuantLib:
_QuantLib.RelinkableYieldTermStructureHandle_swigregister(RelinkableYieldTermStructureHandle)

class ImpliedTermStructure(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, curveHandle, referenceDate):
        _QuantLib.ImpliedTermStructure_swiginit(self, _QuantLib.new_ImpliedTermStructure(curveHandle, referenceDate))
    __swig_destroy__ = _QuantLib.delete_ImpliedTermStructure

# Register ImpliedTermStructure in _QuantLib:
_QuantLib.ImpliedTermStructure_swigregister(ImpliedTermStructure)

class ZeroSpreadedTermStructure(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZeroSpreadedTermStructure_swiginit(self, _QuantLib.new_ZeroSpreadedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_ZeroSpreadedTermStructure

# Register ZeroSpreadedTermStructure in _QuantLib:
_QuantLib.ZeroSpreadedTermStructure_swigregister(ZeroSpreadedTermStructure)

class ForwardSpreadedTermStructure(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, curveHandle, spreadHandle):
        _QuantLib.ForwardSpreadedTermStructure_swiginit(self, _QuantLib.new_ForwardSpreadedTermStructure(curveHandle, spreadHandle))
    __swig_destroy__ = _QuantLib.delete_ForwardSpreadedTermStructure

# Register ForwardSpreadedTermStructure in _QuantLib:
_QuantLib.ForwardSpreadedTermStructure_swigregister(ForwardSpreadedTermStructure)

class SpreadedLinearZeroInterpolatedTermStructure(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SpreadedLinearZeroInterpolatedTermStructure_swiginit(self, _QuantLib.new_SpreadedLinearZeroInterpolatedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadedLinearZeroInterpolatedTermStructure

# Register SpreadedLinearZeroInterpolatedTermStructure in _QuantLib:
_QuantLib.SpreadedLinearZeroInterpolatedTermStructure_swigregister(SpreadedLinearZeroInterpolatedTermStructure)

class SpreadedBackwardFlatZeroInterpolatedTermStructure(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit(self, _QuantLib.new_SpreadedBackwardFlatZeroInterpolatedTermStructure(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadedBackwardFlatZeroInterpolatedTermStructure

# Register SpreadedBackwardFlatZeroInterpolatedTermStructure in _QuantLib:
_QuantLib.SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister(SpreadedBackwardFlatZeroInterpolatedTermStructure)

class FlatForward(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FlatForward_swiginit(self, _QuantLib.new_FlatForward(*args))
    __swig_destroy__ = _QuantLib.delete_FlatForward

# Register FlatForward in _QuantLib:
_QuantLib.FlatForward_swigregister(FlatForward)

class RealTimeSeries(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RealTimeSeries_swiginit(self, _QuantLib.new_RealTimeSeries(*args))

    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, d):
        return _QuantLib.RealTimeSeries___getitem__(self, d)

    def __setitem__(self, d, value):
        return _QuantLib.RealTimeSeries___setitem__(self, d, value)
    __swig_destroy__ = _QuantLib.delete_RealTimeSeries

# Register RealTimeSeries in _QuantLib:
_QuantLib.RealTimeSeries_swigregister(RealTimeSeries)

class IntervalPriceTimeSeries(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.IntervalPriceTimeSeries_swiginit(self, _QuantLib.new_IntervalPriceTimeSeries(*args))

    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, d):
        return _QuantLib.IntervalPriceTimeSeries___getitem__(self, d)

    def __setitem__(self, d, value):
        return _QuantLib.IntervalPriceTimeSeries___setitem__(self, d, value)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceTimeSeries

# Register IntervalPriceTimeSeries in _QuantLib:
_QuantLib.IntervalPriceTimeSeries_swigregister(IntervalPriceTimeSeries)

class IntervalPriceVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.IntervalPriceVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.IntervalPriceVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.IntervalPriceVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.IntervalPriceVector_pop(self)

    def append(self, x):
        return _QuantLib.IntervalPriceVector_append(self, x)

    def empty(self):
        return _QuantLib.IntervalPriceVector_empty(self)

    def size(self):
        return _QuantLib.IntervalPriceVector_size(self)

    def swap(self, v):
        return _QuantLib.IntervalPriceVector_swap(self, v)

    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 clear(self):
        return _QuantLib.IntervalPriceVector_clear(self)

    def get_allocator(self):
        return _QuantLib.IntervalPriceVector_get_allocator(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):
        _QuantLib.IntervalPriceVector_swiginit(self, _QuantLib.new_IntervalPriceVector(*args))

    def push_back(self, x):
        return _QuantLib.IntervalPriceVector_push_back(self, x)

    def front(self):
        return _QuantLib.IntervalPriceVector_front(self)

    def back(self):
        return _QuantLib.IntervalPriceVector_back(self)

    def assign(self, n, x):
        return _QuantLib.IntervalPriceVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.IntervalPriceVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.IntervalPriceVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.IntervalPriceVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.IntervalPriceVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceVector

# Register IntervalPriceVector in _QuantLib:
_QuantLib.IntervalPriceVector_swigregister(IntervalPriceVector)

class IntervalPrice(object):
    thisown = 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, arg2, arg3, arg4, arg5):
        _QuantLib.IntervalPrice_swiginit(self, _QuantLib.new_IntervalPrice(arg2, arg3, arg4, arg5))

    def setValue(self, arg2, arg3):
        return _QuantLib.IntervalPrice_setValue(self, arg2, arg3)

    def setValues(self, arg2, arg3, arg4, arg5):
        return _QuantLib.IntervalPrice_setValues(self, arg2, arg3, arg4, arg5)

    def value(self, t):
        return _QuantLib.IntervalPrice_value(self, t)

    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)

    @staticmethod
    def makeSeries(d, open, close, high, low):
        return _QuantLib.IntervalPrice_makeSeries(d, open, close, high, low)

    @staticmethod
    def extractValues(arg1, t):
        return _QuantLib.IntervalPrice_extractValues(arg1, t)

    @staticmethod
    def extractComponent(arg1, t):
        return _QuantLib.IntervalPrice_extractComponent(arg1, t)
    __swig_destroy__ = _QuantLib.delete_IntervalPrice

# Register IntervalPrice in _QuantLib:
_QuantLib.IntervalPrice_swigregister(IntervalPrice)

def IntervalPrice_makeSeries(d, open, close, high, low):
    return _QuantLib.IntervalPrice_makeSeries(d, open, close, high, low)

def IntervalPrice_extractValues(arg1, t):
    return _QuantLib.IntervalPrice_extractValues(arg1, t)

def IntervalPrice_extractComponent(arg1, t):
    return _QuantLib.IntervalPrice_extractComponent(arg1, t)

class IndexManager(object):
    thisown = 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

    @staticmethod
    def instance():
        return _QuantLib.IndexManager_instance()

    def setHistory(self, name, fixings):
        return _QuantLib.IndexManager_setHistory(self, name, fixings)

    def getHistory(self, name):
        return _QuantLib.IndexManager_getHistory(self, name)

    def hasHistory(self, name):
        return _QuantLib.IndexManager_hasHistory(self, name)

    def histories(self):
        return _QuantLib.IndexManager_histories(self)

    def clearHistory(self, name):
        return _QuantLib.IndexManager_clearHistory(self, name)

    def clearHistories(self):
        return _QuantLib.IndexManager_clearHistories(self)
    __swig_destroy__ = _QuantLib.delete_IndexManager

# Register IndexManager in _QuantLib:
_QuantLib.IndexManager_swigregister(IndexManager)

def IndexManager_instance():
    return _QuantLib.IndexManager_instance()

class Index(Observable):
    thisown = 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 name(self):
        return _QuantLib.Index_name(self)

    def fixingCalendar(self):
        return _QuantLib.Index_fixingCalendar(self)

    def isValidFixingDate(self, fixingDate):
        return _QuantLib.Index_isValidFixingDate(self, fixingDate)

    def fixing(self, fixingDate, forecastTodaysFixing=False):
        return _QuantLib.Index_fixing(self, fixingDate, forecastTodaysFixing)

    def addFixing(self, fixingDate, fixing, forceOverwrite=False):
        return _QuantLib.Index_addFixing(self, fixingDate, fixing, forceOverwrite)

    def timeSeries(self):
        return _QuantLib.Index_timeSeries(self)

    def clearFixings(self):
        return _QuantLib.Index_clearFixings(self)

    def addFixings(self, fixingDates, fixings, forceOverwrite=False):
        return _QuantLib.Index_addFixings(self, fixingDates, fixings, forceOverwrite)

    def __str__(self):
        return _QuantLib.Index___str__(self)
    __swig_destroy__ = _QuantLib.delete_Index

# Register Index in _QuantLib:
_QuantLib.Index_swigregister(Index)

class InterestRateIndex(Index):
    thisown = 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, valueDate):
        return _QuantLib.InterestRateIndex_fixingDate(self, valueDate)

    def currency(self):
        return _QuantLib.InterestRateIndex_currency(self)

    def dayCounter(self):
        return _QuantLib.InterestRateIndex_dayCounter(self)

    def maturityDate(self, valueDate):
        return _QuantLib.InterestRateIndex_maturityDate(self, valueDate)

    def valueDate(self, fixingDate):
        return _QuantLib.InterestRateIndex_valueDate(self, fixingDate)
    __swig_destroy__ = _QuantLib.delete_InterestRateIndex

# Register InterestRateIndex in _QuantLib:
_QuantLib.InterestRateIndex_swigregister(InterestRateIndex)

class IborIndex(InterestRateIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.IborIndex_swiginit(self, _QuantLib.new_IborIndex(*args))

    def businessDayConvention(self):
        return _QuantLib.IborIndex_businessDayConvention(self)

    def endOfMonth(self):
        return _QuantLib.IborIndex_endOfMonth(self)

    def forwardingTermStructure(self):
        return _QuantLib.IborIndex_forwardingTermStructure(self)

    def clone(self, arg2):
        return _QuantLib.IborIndex_clone(self, arg2)
    __swig_destroy__ = _QuantLib.delete_IborIndex

# Register IborIndex in _QuantLib:
_QuantLib.IborIndex_swigregister(IborIndex)


def as_iborindex(index):
    return _QuantLib.as_iborindex(index)
class OvernightIndex(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.OvernightIndex_swiginit(self, _QuantLib.new_OvernightIndex(*args))

    def clone(self, h):
        return _QuantLib.OvernightIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_OvernightIndex

# Register OvernightIndex in _QuantLib:
_QuantLib.OvernightIndex_swigregister(OvernightIndex)

class Libor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Libor_swiginit(self, _QuantLib.new_Libor(*args))
    __swig_destroy__ = _QuantLib.delete_Libor

# Register Libor in _QuantLib:
_QuantLib.Libor_swigregister(Libor)

class DailyTenorLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DailyTenorLibor_swiginit(self, _QuantLib.new_DailyTenorLibor(*args))
    __swig_destroy__ = _QuantLib.delete_DailyTenorLibor

# Register DailyTenorLibor in _QuantLib:
_QuantLib.DailyTenorLibor_swigregister(DailyTenorLibor)

class SwapIndex(InterestRateIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SwapIndex_swiginit(self, _QuantLib.new_SwapIndex(*args))

    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)

    def discountingTermStructure(self):
        return _QuantLib.SwapIndex_discountingTermStructure(self)

    def clone(self, *args):
        return _QuantLib.SwapIndex_clone(self, *args)
    __swig_destroy__ = _QuantLib.delete_SwapIndex

# Register SwapIndex in _QuantLib:
_QuantLib.SwapIndex_swigregister(SwapIndex)

class SwapIndexVector(object):
    thisown = 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.SwapIndexVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.SwapIndexVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.SwapIndexVector___bool__(self)

    def __len__(self):
        return _QuantLib.SwapIndexVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.SwapIndexVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.SwapIndexVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.SwapIndexVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.SwapIndexVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.SwapIndexVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.SwapIndexVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.SwapIndexVector_pop(self)

    def append(self, x):
        return _QuantLib.SwapIndexVector_append(self, x)

    def empty(self):
        return _QuantLib.SwapIndexVector_empty(self)

    def size(self):
        return _QuantLib.SwapIndexVector_size(self)

    def swap(self, v):
        return _QuantLib.SwapIndexVector_swap(self, v)

    def begin(self):
        return _QuantLib.SwapIndexVector_begin(self)

    def end(self):
        return _QuantLib.SwapIndexVector_end(self)

    def rbegin(self):
        return _QuantLib.SwapIndexVector_rbegin(self)

    def rend(self):
        return _QuantLib.SwapIndexVector_rend(self)

    def clear(self):
        return _QuantLib.SwapIndexVector_clear(self)

    def get_allocator(self):
        return _QuantLib.SwapIndexVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.SwapIndexVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.SwapIndexVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.SwapIndexVector_swiginit(self, _QuantLib.new_SwapIndexVector(*args))

    def push_back(self, x):
        return _QuantLib.SwapIndexVector_push_back(self, x)

    def front(self):
        return _QuantLib.SwapIndexVector_front(self)

    def back(self):
        return _QuantLib.SwapIndexVector_back(self)

    def assign(self, n, x):
        return _QuantLib.SwapIndexVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.SwapIndexVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.SwapIndexVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.SwapIndexVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.SwapIndexVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_SwapIndexVector

# Register SwapIndexVector in _QuantLib:
_QuantLib.SwapIndexVector_swigregister(SwapIndexVector)


def as_swap_index(index):
    return _QuantLib.as_swap_index(index)
class SwapSpreadIndex(InterestRateIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, familyName, swapIndex1, swapIndex2, gearing1=1.0, gearing2=-1.0):
        _QuantLib.SwapSpreadIndex_swiginit(self, _QuantLib.new_SwapSpreadIndex(familyName, swapIndex1, swapIndex2, gearing1, gearing2))

    def forecastFixing(self, fixingDate):
        return _QuantLib.SwapSpreadIndex_forecastFixing(self, fixingDate)

    def pastFixing(self, fixingDate):
        return _QuantLib.SwapSpreadIndex_pastFixing(self, fixingDate)

    def swapIndex1(self):
        return _QuantLib.SwapSpreadIndex_swapIndex1(self)

    def swapIndex2(self):
        return _QuantLib.SwapSpreadIndex_swapIndex2(self)

    def gearing1(self):
        return _QuantLib.SwapSpreadIndex_gearing1(self)

    def gearing2(self):
        return _QuantLib.SwapSpreadIndex_gearing2(self)
    __swig_destroy__ = _QuantLib.delete_SwapSpreadIndex

# Register SwapSpreadIndex in _QuantLib:
_QuantLib.SwapSpreadIndex_swigregister(SwapSpreadIndex)

class AUDLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.AUDLibor_swiginit(self, _QuantLib.new_AUDLibor(*args))
    __swig_destroy__ = _QuantLib.delete_AUDLibor

# Register AUDLibor in _QuantLib:
_QuantLib.AUDLibor_swigregister(AUDLibor)

class CADLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CADLibor_swiginit(self, _QuantLib.new_CADLibor(*args))
    __swig_destroy__ = _QuantLib.delete_CADLibor

# Register CADLibor in _QuantLib:
_QuantLib.CADLibor_swigregister(CADLibor)

class CADLiborON(DailyTenorLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CADLiborON_swiginit(self, _QuantLib.new_CADLiborON(*args))
    __swig_destroy__ = _QuantLib.delete_CADLiborON

# Register CADLiborON in _QuantLib:
_QuantLib.CADLiborON_swigregister(CADLiborON)

class Cdor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Cdor_swiginit(self, _QuantLib.new_Cdor(*args))
    __swig_destroy__ = _QuantLib.delete_Cdor

# Register Cdor in _QuantLib:
_QuantLib.Cdor_swigregister(Cdor)

class CHFLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CHFLibor_swiginit(self, _QuantLib.new_CHFLibor(*args))
    __swig_destroy__ = _QuantLib.delete_CHFLibor

# Register CHFLibor in _QuantLib:
_QuantLib.CHFLibor_swigregister(CHFLibor)

class DKKLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DKKLibor_swiginit(self, _QuantLib.new_DKKLibor(*args))
    __swig_destroy__ = _QuantLib.delete_DKKLibor

# Register DKKLibor in _QuantLib:
_QuantLib.DKKLibor_swigregister(DKKLibor)

class Bbsw(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw_swiginit(self, _QuantLib.new_Bbsw(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw

# Register Bbsw in _QuantLib:
_QuantLib.Bbsw_swigregister(Bbsw)

class Bbsw1M(Bbsw):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw1M_swiginit(self, _QuantLib.new_Bbsw1M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw1M

# Register Bbsw1M in _QuantLib:
_QuantLib.Bbsw1M_swigregister(Bbsw1M)

class Bbsw2M(Bbsw):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw2M_swiginit(self, _QuantLib.new_Bbsw2M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw2M

# Register Bbsw2M in _QuantLib:
_QuantLib.Bbsw2M_swigregister(Bbsw2M)

class Bbsw3M(Bbsw):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw3M_swiginit(self, _QuantLib.new_Bbsw3M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw3M

# Register Bbsw3M in _QuantLib:
_QuantLib.Bbsw3M_swigregister(Bbsw3M)

class Bbsw4M(Bbsw):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw4M_swiginit(self, _QuantLib.new_Bbsw4M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw4M

# Register Bbsw4M in _QuantLib:
_QuantLib.Bbsw4M_swigregister(Bbsw4M)

class Bbsw5M(Bbsw):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw5M_swiginit(self, _QuantLib.new_Bbsw5M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw5M

# Register Bbsw5M in _QuantLib:
_QuantLib.Bbsw5M_swigregister(Bbsw5M)

class Bbsw6M(Bbsw):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bbsw6M_swiginit(self, _QuantLib.new_Bbsw6M(*args))
    __swig_destroy__ = _QuantLib.delete_Bbsw6M

# Register Bbsw6M in _QuantLib:
_QuantLib.Bbsw6M_swigregister(Bbsw6M)

class Bkbm(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm_swiginit(self, _QuantLib.new_Bkbm(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm

# Register Bkbm in _QuantLib:
_QuantLib.Bkbm_swigregister(Bkbm)

class Bkbm1M(Bkbm):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm1M_swiginit(self, _QuantLib.new_Bkbm1M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm1M

# Register Bkbm1M in _QuantLib:
_QuantLib.Bkbm1M_swigregister(Bkbm1M)

class Bkbm2M(Bkbm):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm2M_swiginit(self, _QuantLib.new_Bkbm2M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm2M

# Register Bkbm2M in _QuantLib:
_QuantLib.Bkbm2M_swigregister(Bkbm2M)

class Bkbm3M(Bkbm):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm3M_swiginit(self, _QuantLib.new_Bkbm3M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm3M

# Register Bkbm3M in _QuantLib:
_QuantLib.Bkbm3M_swigregister(Bkbm3M)

class Bkbm4M(Bkbm):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm4M_swiginit(self, _QuantLib.new_Bkbm4M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm4M

# Register Bkbm4M in _QuantLib:
_QuantLib.Bkbm4M_swigregister(Bkbm4M)

class Bkbm5M(Bkbm):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm5M_swiginit(self, _QuantLib.new_Bkbm5M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm5M

# Register Bkbm5M in _QuantLib:
_QuantLib.Bkbm5M_swigregister(Bkbm5M)

class Bkbm6M(Bkbm):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bkbm6M_swiginit(self, _QuantLib.new_Bkbm6M(*args))
    __swig_destroy__ = _QuantLib.delete_Bkbm6M

# Register Bkbm6M in _QuantLib:
_QuantLib.Bkbm6M_swigregister(Bkbm6M)

class Euribor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor_swiginit(self, _QuantLib.new_Euribor(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor

# Register Euribor in _QuantLib:
_QuantLib.Euribor_swigregister(Euribor)

class EuriborSW(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EuriborSW_swiginit(self, _QuantLib.new_EuriborSW(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSW

# Register EuriborSW in _QuantLib:
_QuantLib.EuriborSW_swigregister(EuriborSW)

class Euribor2W(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor2W_swiginit(self, _QuantLib.new_Euribor2W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor2W

# Register Euribor2W in _QuantLib:
_QuantLib.Euribor2W_swigregister(Euribor2W)

class Euribor3W(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor3W_swiginit(self, _QuantLib.new_Euribor3W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor3W

# Register Euribor3W in _QuantLib:
_QuantLib.Euribor3W_swigregister(Euribor3W)

class Euribor1M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor1M_swiginit(self, _QuantLib.new_Euribor1M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor1M

# Register Euribor1M in _QuantLib:
_QuantLib.Euribor1M_swigregister(Euribor1M)

class Euribor2M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor2M_swiginit(self, _QuantLib.new_Euribor2M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor2M

# Register Euribor2M in _QuantLib:
_QuantLib.Euribor2M_swigregister(Euribor2M)

class Euribor3M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor3M_swiginit(self, _QuantLib.new_Euribor3M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor3M

# Register Euribor3M in _QuantLib:
_QuantLib.Euribor3M_swigregister(Euribor3M)

class Euribor4M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor4M_swiginit(self, _QuantLib.new_Euribor4M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor4M

# Register Euribor4M in _QuantLib:
_QuantLib.Euribor4M_swigregister(Euribor4M)

class Euribor5M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor5M_swiginit(self, _QuantLib.new_Euribor5M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor5M

# Register Euribor5M in _QuantLib:
_QuantLib.Euribor5M_swigregister(Euribor5M)

class Euribor6M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor6M_swiginit(self, _QuantLib.new_Euribor6M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor6M

# Register Euribor6M in _QuantLib:
_QuantLib.Euribor6M_swigregister(Euribor6M)

class Euribor7M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor7M_swiginit(self, _QuantLib.new_Euribor7M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor7M

# Register Euribor7M in _QuantLib:
_QuantLib.Euribor7M_swigregister(Euribor7M)

class Euribor8M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor8M_swiginit(self, _QuantLib.new_Euribor8M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor8M

# Register Euribor8M in _QuantLib:
_QuantLib.Euribor8M_swigregister(Euribor8M)

class Euribor9M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor9M_swiginit(self, _QuantLib.new_Euribor9M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor9M

# Register Euribor9M in _QuantLib:
_QuantLib.Euribor9M_swigregister(Euribor9M)

class Euribor10M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor10M_swiginit(self, _QuantLib.new_Euribor10M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor10M

# Register Euribor10M in _QuantLib:
_QuantLib.Euribor10M_swigregister(Euribor10M)

class Euribor11M(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor11M_swiginit(self, _QuantLib.new_Euribor11M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor11M

# Register Euribor11M in _QuantLib:
_QuantLib.Euribor11M_swigregister(Euribor11M)

class Euribor1Y(Euribor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor1Y_swiginit(self, _QuantLib.new_Euribor1Y(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor1Y

# Register Euribor1Y in _QuantLib:
_QuantLib.Euribor1Y_swigregister(Euribor1Y)

class Euribor365(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_swiginit(self, _QuantLib.new_Euribor365(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365

# Register Euribor365 in _QuantLib:
_QuantLib.Euribor365_swigregister(Euribor365)

class Euribor365_SW(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_SW_swiginit(self, _QuantLib.new_Euribor365_SW(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_SW

# Register Euribor365_SW in _QuantLib:
_QuantLib.Euribor365_SW_swigregister(Euribor365_SW)

class Euribor365_2W(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_2W_swiginit(self, _QuantLib.new_Euribor365_2W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_2W

# Register Euribor365_2W in _QuantLib:
_QuantLib.Euribor365_2W_swigregister(Euribor365_2W)

class Euribor365_3W(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_3W_swiginit(self, _QuantLib.new_Euribor365_3W(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_3W

# Register Euribor365_3W in _QuantLib:
_QuantLib.Euribor365_3W_swigregister(Euribor365_3W)

class Euribor365_1M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_1M_swiginit(self, _QuantLib.new_Euribor365_1M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_1M

# Register Euribor365_1M in _QuantLib:
_QuantLib.Euribor365_1M_swigregister(Euribor365_1M)

class Euribor365_2M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_2M_swiginit(self, _QuantLib.new_Euribor365_2M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_2M

# Register Euribor365_2M in _QuantLib:
_QuantLib.Euribor365_2M_swigregister(Euribor365_2M)

class Euribor365_3M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_3M_swiginit(self, _QuantLib.new_Euribor365_3M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_3M

# Register Euribor365_3M in _QuantLib:
_QuantLib.Euribor365_3M_swigregister(Euribor365_3M)

class Euribor365_4M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_4M_swiginit(self, _QuantLib.new_Euribor365_4M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_4M

# Register Euribor365_4M in _QuantLib:
_QuantLib.Euribor365_4M_swigregister(Euribor365_4M)

class Euribor365_5M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_5M_swiginit(self, _QuantLib.new_Euribor365_5M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_5M

# Register Euribor365_5M in _QuantLib:
_QuantLib.Euribor365_5M_swigregister(Euribor365_5M)

class Euribor365_6M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_6M_swiginit(self, _QuantLib.new_Euribor365_6M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_6M

# Register Euribor365_6M in _QuantLib:
_QuantLib.Euribor365_6M_swigregister(Euribor365_6M)

class Euribor365_7M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_7M_swiginit(self, _QuantLib.new_Euribor365_7M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_7M

# Register Euribor365_7M in _QuantLib:
_QuantLib.Euribor365_7M_swigregister(Euribor365_7M)

class Euribor365_8M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_8M_swiginit(self, _QuantLib.new_Euribor365_8M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_8M

# Register Euribor365_8M in _QuantLib:
_QuantLib.Euribor365_8M_swigregister(Euribor365_8M)

class Euribor365_9M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_9M_swiginit(self, _QuantLib.new_Euribor365_9M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_9M

# Register Euribor365_9M in _QuantLib:
_QuantLib.Euribor365_9M_swigregister(Euribor365_9M)

class Euribor365_10M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_10M_swiginit(self, _QuantLib.new_Euribor365_10M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_10M

# Register Euribor365_10M in _QuantLib:
_QuantLib.Euribor365_10M_swigregister(Euribor365_10M)

class Euribor365_11M(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_11M_swiginit(self, _QuantLib.new_Euribor365_11M(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_11M

# Register Euribor365_11M in _QuantLib:
_QuantLib.Euribor365_11M_swigregister(Euribor365_11M)

class Euribor365_1Y(Euribor365):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Euribor365_1Y_swiginit(self, _QuantLib.new_Euribor365_1Y(*args))
    __swig_destroy__ = _QuantLib.delete_Euribor365_1Y

# Register Euribor365_1Y in _QuantLib:
_QuantLib.Euribor365_1Y_swigregister(Euribor365_1Y)

class EURLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor_swiginit(self, _QuantLib.new_EURLibor(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor

# Register EURLibor in _QuantLib:
_QuantLib.EURLibor_swigregister(EURLibor)

class EURLiborSW(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLiborSW_swiginit(self, _QuantLib.new_EURLiborSW(*args))
    __swig_destroy__ = _QuantLib.delete_EURLiborSW

# Register EURLiborSW in _QuantLib:
_QuantLib.EURLiborSW_swigregister(EURLiborSW)

class EURLibor2W(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor2W_swiginit(self, _QuantLib.new_EURLibor2W(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor2W

# Register EURLibor2W in _QuantLib:
_QuantLib.EURLibor2W_swigregister(EURLibor2W)

class EURLibor1M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor1M_swiginit(self, _QuantLib.new_EURLibor1M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor1M

# Register EURLibor1M in _QuantLib:
_QuantLib.EURLibor1M_swigregister(EURLibor1M)

class EURLibor2M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor2M_swiginit(self, _QuantLib.new_EURLibor2M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor2M

# Register EURLibor2M in _QuantLib:
_QuantLib.EURLibor2M_swigregister(EURLibor2M)

class EURLibor3M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor3M_swiginit(self, _QuantLib.new_EURLibor3M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor3M

# Register EURLibor3M in _QuantLib:
_QuantLib.EURLibor3M_swigregister(EURLibor3M)

class EURLibor4M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor4M_swiginit(self, _QuantLib.new_EURLibor4M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor4M

# Register EURLibor4M in _QuantLib:
_QuantLib.EURLibor4M_swigregister(EURLibor4M)

class EURLibor5M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor5M_swiginit(self, _QuantLib.new_EURLibor5M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor5M

# Register EURLibor5M in _QuantLib:
_QuantLib.EURLibor5M_swigregister(EURLibor5M)

class EURLibor6M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor6M_swiginit(self, _QuantLib.new_EURLibor6M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor6M

# Register EURLibor6M in _QuantLib:
_QuantLib.EURLibor6M_swigregister(EURLibor6M)

class EURLibor7M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor7M_swiginit(self, _QuantLib.new_EURLibor7M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor7M

# Register EURLibor7M in _QuantLib:
_QuantLib.EURLibor7M_swigregister(EURLibor7M)

class EURLibor8M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor8M_swiginit(self, _QuantLib.new_EURLibor8M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor8M

# Register EURLibor8M in _QuantLib:
_QuantLib.EURLibor8M_swigregister(EURLibor8M)

class EURLibor9M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor9M_swiginit(self, _QuantLib.new_EURLibor9M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor9M

# Register EURLibor9M in _QuantLib:
_QuantLib.EURLibor9M_swigregister(EURLibor9M)

class EURLibor10M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor10M_swiginit(self, _QuantLib.new_EURLibor10M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor10M

# Register EURLibor10M in _QuantLib:
_QuantLib.EURLibor10M_swigregister(EURLibor10M)

class EURLibor11M(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor11M_swiginit(self, _QuantLib.new_EURLibor11M(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor11M

# Register EURLibor11M in _QuantLib:
_QuantLib.EURLibor11M_swigregister(EURLibor11M)

class EURLibor1Y(EURLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EURLibor1Y_swiginit(self, _QuantLib.new_EURLibor1Y(*args))
    __swig_destroy__ = _QuantLib.delete_EURLibor1Y

# Register EURLibor1Y in _QuantLib:
_QuantLib.EURLibor1Y_swigregister(EURLibor1Y)

class GBPLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GBPLibor_swiginit(self, _QuantLib.new_GBPLibor(*args))
    __swig_destroy__ = _QuantLib.delete_GBPLibor

# Register GBPLibor in _QuantLib:
_QuantLib.GBPLibor_swigregister(GBPLibor)

class GBPLiborON(DailyTenorLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GBPLiborON_swiginit(self, _QuantLib.new_GBPLiborON(*args))
    __swig_destroy__ = _QuantLib.delete_GBPLiborON

# Register GBPLiborON in _QuantLib:
_QuantLib.GBPLiborON_swigregister(GBPLiborON)

class Jibar(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Jibar_swiginit(self, _QuantLib.new_Jibar(*args))
    __swig_destroy__ = _QuantLib.delete_Jibar

# Register Jibar in _QuantLib:
_QuantLib.Jibar_swigregister(Jibar)

class JPYLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.JPYLibor_swiginit(self, _QuantLib.new_JPYLibor(*args))
    __swig_destroy__ = _QuantLib.delete_JPYLibor

# Register JPYLibor in _QuantLib:
_QuantLib.JPYLibor_swigregister(JPYLibor)

class Mosprime(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Mosprime_swiginit(self, _QuantLib.new_Mosprime(*args))
    __swig_destroy__ = _QuantLib.delete_Mosprime

# Register Mosprime in _QuantLib:
_QuantLib.Mosprime_swigregister(Mosprime)

class NZDLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NZDLibor_swiginit(self, _QuantLib.new_NZDLibor(*args))
    __swig_destroy__ = _QuantLib.delete_NZDLibor

# Register NZDLibor in _QuantLib:
_QuantLib.NZDLibor_swigregister(NZDLibor)

class Pribor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Pribor_swiginit(self, _QuantLib.new_Pribor(*args))
    __swig_destroy__ = _QuantLib.delete_Pribor

# Register Pribor in _QuantLib:
_QuantLib.Pribor_swigregister(Pribor)

class Robor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Robor_swiginit(self, _QuantLib.new_Robor(*args))
    __swig_destroy__ = _QuantLib.delete_Robor

# Register Robor in _QuantLib:
_QuantLib.Robor_swigregister(Robor)

class SEKLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SEKLibor_swiginit(self, _QuantLib.new_SEKLibor(*args))
    __swig_destroy__ = _QuantLib.delete_SEKLibor

# Register SEKLibor in _QuantLib:
_QuantLib.SEKLibor_swigregister(SEKLibor)

class Shibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Shibor_swiginit(self, _QuantLib.new_Shibor(*args))
    __swig_destroy__ = _QuantLib.delete_Shibor

# Register Shibor in _QuantLib:
_QuantLib.Shibor_swigregister(Shibor)

class Tibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Tibor_swiginit(self, _QuantLib.new_Tibor(*args))
    __swig_destroy__ = _QuantLib.delete_Tibor

# Register Tibor in _QuantLib:
_QuantLib.Tibor_swigregister(Tibor)

class THBFIX(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.THBFIX_swiginit(self, _QuantLib.new_THBFIX(*args))
    __swig_destroy__ = _QuantLib.delete_THBFIX

# Register THBFIX in _QuantLib:
_QuantLib.THBFIX_swigregister(THBFIX)

class TRLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.TRLibor_swiginit(self, _QuantLib.new_TRLibor(*args))
    __swig_destroy__ = _QuantLib.delete_TRLibor

# Register TRLibor in _QuantLib:
_QuantLib.TRLibor_swigregister(TRLibor)

class USDLibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.USDLibor_swiginit(self, _QuantLib.new_USDLibor(*args))
    __swig_destroy__ = _QuantLib.delete_USDLibor

# Register USDLibor in _QuantLib:
_QuantLib.USDLibor_swigregister(USDLibor)

class USDLiborON(DailyTenorLibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.USDLiborON_swiginit(self, _QuantLib.new_USDLiborON(*args))
    __swig_destroy__ = _QuantLib.delete_USDLiborON

# Register USDLiborON in _QuantLib:
_QuantLib.USDLiborON_swigregister(USDLiborON)

class Wibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Wibor_swiginit(self, _QuantLib.new_Wibor(*args))
    __swig_destroy__ = _QuantLib.delete_Wibor

# Register Wibor in _QuantLib:
_QuantLib.Wibor_swigregister(Wibor)

class Zibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Zibor_swiginit(self, _QuantLib.new_Zibor(*args))
    __swig_destroy__ = _QuantLib.delete_Zibor

# Register Zibor in _QuantLib:
_QuantLib.Zibor_swigregister(Zibor)

class Aonia(OvernightIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Aonia_swiginit(self, _QuantLib.new_Aonia(*args))
    __swig_destroy__ = _QuantLib.delete_Aonia

# Register Aonia in _QuantLib:
_QuantLib.Aonia_swigregister(Aonia)

class Eonia(OvernightIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Eonia_swiginit(self, _QuantLib.new_Eonia(*args))
    __swig_destroy__ = _QuantLib.delete_Eonia

# Register Eonia in _QuantLib:
_QuantLib.Eonia_swigregister(Eonia)

class Sonia(OvernightIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Sonia_swiginit(self, _QuantLib.new_Sonia(*args))
    __swig_destroy__ = _QuantLib.delete_Sonia

# Register Sonia in _QuantLib:
_QuantLib.Sonia_swigregister(Sonia)

class FedFunds(OvernightIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FedFunds_swiginit(self, _QuantLib.new_FedFunds(*args))
    __swig_destroy__ = _QuantLib.delete_FedFunds

# Register FedFunds in _QuantLib:
_QuantLib.FedFunds_swigregister(FedFunds)

class Nzocr(OvernightIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Nzocr_swiginit(self, _QuantLib.new_Nzocr(*args))
    __swig_destroy__ = _QuantLib.delete_Nzocr

# Register Nzocr in _QuantLib:
_QuantLib.Nzocr_swigregister(Nzocr)

class Sofr(OvernightIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Sofr_swiginit(self, _QuantLib.new_Sofr(*args))
    __swig_destroy__ = _QuantLib.delete_Sofr

# Register Sofr in _QuantLib:
_QuantLib.Sofr_swigregister(Sofr)

class EuriborSwapIsdaFixA(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EuriborSwapIsdaFixA_swiginit(self, _QuantLib.new_EuriborSwapIsdaFixA(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixA

# Register EuriborSwapIsdaFixA in _QuantLib:
_QuantLib.EuriborSwapIsdaFixA_swigregister(EuriborSwapIsdaFixA)

class EuriborSwapIsdaFixB(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EuriborSwapIsdaFixB_swiginit(self, _QuantLib.new_EuriborSwapIsdaFixB(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixB

# Register EuriborSwapIsdaFixB in _QuantLib:
_QuantLib.EuriborSwapIsdaFixB_swigregister(EuriborSwapIsdaFixB)

class EuriborSwapIfrFix(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EuriborSwapIfrFix_swiginit(self, _QuantLib.new_EuriborSwapIfrFix(*args))
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIfrFix

# Register EuriborSwapIfrFix in _QuantLib:
_QuantLib.EuriborSwapIfrFix_swigregister(EuriborSwapIfrFix)

class EurLiborSwapIsdaFixA(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EurLiborSwapIsdaFixA_swiginit(self, _QuantLib.new_EurLiborSwapIsdaFixA(*args))
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixA

# Register EurLiborSwapIsdaFixA in _QuantLib:
_QuantLib.EurLiborSwapIsdaFixA_swigregister(EurLiborSwapIsdaFixA)

class EurLiborSwapIsdaFixB(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EurLiborSwapIsdaFixB_swiginit(self, _QuantLib.new_EurLiborSwapIsdaFixB(*args))
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixB

# Register EurLiborSwapIsdaFixB in _QuantLib:
_QuantLib.EurLiborSwapIsdaFixB_swigregister(EurLiborSwapIsdaFixB)

class EurLiborSwapIfrFix(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EurLiborSwapIfrFix_swiginit(self, _QuantLib.new_EurLiborSwapIfrFix(*args))
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIfrFix

# Register EurLiborSwapIfrFix in _QuantLib:
_QuantLib.EurLiborSwapIfrFix_swigregister(EurLiborSwapIfrFix)

class ChfLiborSwapIsdaFix(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ChfLiborSwapIsdaFix_swiginit(self, _QuantLib.new_ChfLiborSwapIsdaFix(*args))
    __swig_destroy__ = _QuantLib.delete_ChfLiborSwapIsdaFix

# Register ChfLiborSwapIsdaFix in _QuantLib:
_QuantLib.ChfLiborSwapIsdaFix_swigregister(ChfLiborSwapIsdaFix)

class GbpLiborSwapIsdaFix(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GbpLiborSwapIsdaFix_swiginit(self, _QuantLib.new_GbpLiborSwapIsdaFix(*args))
    __swig_destroy__ = _QuantLib.delete_GbpLiborSwapIsdaFix

# Register GbpLiborSwapIsdaFix in _QuantLib:
_QuantLib.GbpLiborSwapIsdaFix_swigregister(GbpLiborSwapIsdaFix)

class JpyLiborSwapIsdaFixAm(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.JpyLiborSwapIsdaFixAm_swiginit(self, _QuantLib.new_JpyLiborSwapIsdaFixAm(*args))
    __swig_destroy__ = _QuantLib.delete_JpyLiborSwapIsdaFixAm

# Register JpyLiborSwapIsdaFixAm in _QuantLib:
_QuantLib.JpyLiborSwapIsdaFixAm_swigregister(JpyLiborSwapIsdaFixAm)

class JpyLiborSwapIsdaFixPm(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.JpyLiborSwapIsdaFixPm_swiginit(self, _QuantLib.new_JpyLiborSwapIsdaFixPm(*args))
    __swig_destroy__ = _QuantLib.delete_JpyLiborSwapIsdaFixPm

# Register JpyLiborSwapIsdaFixPm in _QuantLib:
_QuantLib.JpyLiborSwapIsdaFixPm_swigregister(JpyLiborSwapIsdaFixPm)

class UsdLiborSwapIsdaFixAm(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.UsdLiborSwapIsdaFixAm_swiginit(self, _QuantLib.new_UsdLiborSwapIsdaFixAm(*args))
    __swig_destroy__ = _QuantLib.delete_UsdLiborSwapIsdaFixAm

# Register UsdLiborSwapIsdaFixAm in _QuantLib:
_QuantLib.UsdLiborSwapIsdaFixAm_swigregister(UsdLiborSwapIsdaFixAm)

class UsdLiborSwapIsdaFixPm(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.UsdLiborSwapIsdaFixPm_swiginit(self, _QuantLib.new_UsdLiborSwapIsdaFixPm(*args))
    __swig_destroy__ = _QuantLib.delete_UsdLiborSwapIsdaFixPm

# Register UsdLiborSwapIsdaFixPm in _QuantLib:
_QuantLib.UsdLiborSwapIsdaFixPm_swigregister(UsdLiborSwapIsdaFixPm)

class Bibor(IborIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor_swiginit(self, _QuantLib.new_Bibor(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor

# Register Bibor in _QuantLib:
_QuantLib.Bibor_swigregister(Bibor)

class BiborSW(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BiborSW_swiginit(self, _QuantLib.new_BiborSW(*args))
    __swig_destroy__ = _QuantLib.delete_BiborSW

# Register BiborSW in _QuantLib:
_QuantLib.BiborSW_swigregister(BiborSW)

class Bibor1M(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor1M_swiginit(self, _QuantLib.new_Bibor1M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor1M

# Register Bibor1M in _QuantLib:
_QuantLib.Bibor1M_swigregister(Bibor1M)

class Bibor2M(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor2M_swiginit(self, _QuantLib.new_Bibor2M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor2M

# Register Bibor2M in _QuantLib:
_QuantLib.Bibor2M_swigregister(Bibor2M)

class Bibor3M(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor3M_swiginit(self, _QuantLib.new_Bibor3M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor3M

# Register Bibor3M in _QuantLib:
_QuantLib.Bibor3M_swigregister(Bibor3M)

class Bibor6M(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor6M_swiginit(self, _QuantLib.new_Bibor6M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor6M

# Register Bibor6M in _QuantLib:
_QuantLib.Bibor6M_swigregister(Bibor6M)

class Bibor9M(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor9M_swiginit(self, _QuantLib.new_Bibor9M(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor9M

# Register Bibor9M in _QuantLib:
_QuantLib.Bibor9M_swigregister(Bibor9M)

class Bibor1Y(Bibor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bibor1Y_swiginit(self, _QuantLib.new_Bibor1Y(*args))
    __swig_destroy__ = _QuantLib.delete_Bibor1Y

# Register Bibor1Y in _QuantLib:
_QuantLib.Bibor1Y_swigregister(Bibor1Y)

ShiftedLognormal = _QuantLib.ShiftedLognormal
Normal = _QuantLib.Normal
class VolatilityTermStructure(TermStructure):
    thisown = 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 minStrike(self):
        return _QuantLib.VolatilityTermStructure_minStrike(self)

    def maxStrike(self):
        return _QuantLib.VolatilityTermStructure_maxStrike(self)
    __swig_destroy__ = _QuantLib.delete_VolatilityTermStructure

# Register VolatilityTermStructure in _QuantLib:
_QuantLib.VolatilityTermStructure_swigregister(VolatilityTermStructure)

class BlackVolTermStructure(VolatilityTermStructure):
    thisown = 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 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)
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructure

# Register BlackVolTermStructure in _QuantLib:
_QuantLib.BlackVolTermStructure_swigregister(BlackVolTermStructure)

class BlackVolTermStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BlackVolTermStructureHandle_swiginit(self, _QuantLib.new_BlackVolTermStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.BlackVolTermStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.BlackVolTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.BlackVolTermStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.BlackVolTermStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.BlackVolTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructureHandle

    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 minStrike(self):
        return _QuantLib.BlackVolTermStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.BlackVolTermStructureHandle_maxStrike(self)

    def dayCounter(self):
        return _QuantLib.BlackVolTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.BlackVolTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.BlackVolTermStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.BlackVolTermStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.BlackVolTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.BlackVolTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.BlackVolTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.BlackVolTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.BlackVolTermStructureHandle_allowsExtrapolation(self)

# Register BlackVolTermStructureHandle in _QuantLib:
_QuantLib.BlackVolTermStructureHandle_swigregister(BlackVolTermStructureHandle)

class RelinkableBlackVolTermStructureHandle(BlackVolTermStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableBlackVolTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableBlackVolTermStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableBlackVolTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableBlackVolTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableBlackVolTermStructureHandle

# Register RelinkableBlackVolTermStructureHandle in _QuantLib:
_QuantLib.RelinkableBlackVolTermStructureHandle_swigregister(RelinkableBlackVolTermStructureHandle)

class LocalVolTermStructure(VolatilityTermStructure):
    thisown = 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 localVol(self, *args):
        return _QuantLib.LocalVolTermStructure_localVol(self, *args)
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructure

# Register LocalVolTermStructure in _QuantLib:
_QuantLib.LocalVolTermStructure_swigregister(LocalVolTermStructure)

class LocalVolTermStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LocalVolTermStructureHandle_swiginit(self, _QuantLib.new_LocalVolTermStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.LocalVolTermStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.LocalVolTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.LocalVolTermStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.LocalVolTermStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.LocalVolTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructureHandle

    def localVol(self, *args):
        return _QuantLib.LocalVolTermStructureHandle_localVol(self, *args)

    def minStrike(self):
        return _QuantLib.LocalVolTermStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.LocalVolTermStructureHandle_maxStrike(self)

    def dayCounter(self):
        return _QuantLib.LocalVolTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.LocalVolTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.LocalVolTermStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.LocalVolTermStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.LocalVolTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.LocalVolTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.LocalVolTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.LocalVolTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.LocalVolTermStructureHandle_allowsExtrapolation(self)

# Register LocalVolTermStructureHandle in _QuantLib:
_QuantLib.LocalVolTermStructureHandle_swigregister(LocalVolTermStructureHandle)

class RelinkableLocalVolTermStructureHandle(LocalVolTermStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableLocalVolTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableLocalVolTermStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableLocalVolTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableLocalVolTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableLocalVolTermStructureHandle

# Register RelinkableLocalVolTermStructureHandle in _QuantLib:
_QuantLib.RelinkableLocalVolTermStructureHandle_swigregister(RelinkableLocalVolTermStructureHandle)

class OptionletVolatilityStructure(VolatilityTermStructure):
    thisown = 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 volatility(self, *args):
        return _QuantLib.OptionletVolatilityStructure_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.OptionletVolatilityStructure_blackVariance(self, *args)
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructure

# Register OptionletVolatilityStructure in _QuantLib:
_QuantLib.OptionletVolatilityStructure_swigregister(OptionletVolatilityStructure)

class OptionletVolatilityStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.OptionletVolatilityStructureHandle_swiginit(self, _QuantLib.new_OptionletVolatilityStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.OptionletVolatilityStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.OptionletVolatilityStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.OptionletVolatilityStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.OptionletVolatilityStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.OptionletVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructureHandle

    def volatility(self, *args):
        return _QuantLib.OptionletVolatilityStructureHandle_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.OptionletVolatilityStructureHandle_blackVariance(self, *args)

    def minStrike(self):
        return _QuantLib.OptionletVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.OptionletVolatilityStructureHandle_maxStrike(self)

    def dayCounter(self):
        return _QuantLib.OptionletVolatilityStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.OptionletVolatilityStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.OptionletVolatilityStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.OptionletVolatilityStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.OptionletVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.OptionletVolatilityStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructureHandle_allowsExtrapolation(self)

# Register OptionletVolatilityStructureHandle in _QuantLib:
_QuantLib.OptionletVolatilityStructureHandle_swigregister(OptionletVolatilityStructureHandle)

class RelinkableOptionletVolatilityStructureHandle(OptionletVolatilityStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableOptionletVolatilityStructureHandle_swiginit(self, _QuantLib.new_RelinkableOptionletVolatilityStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableOptionletVolatilityStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableOptionletVolatilityStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableOptionletVolatilityStructureHandle

# Register RelinkableOptionletVolatilityStructureHandle in _QuantLib:
_QuantLib.RelinkableOptionletVolatilityStructureHandle_swigregister(RelinkableOptionletVolatilityStructureHandle)

class YoYOptionletVolatilitySurface(VolatilityTermStructure):
    thisown = 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 observationLag(self):
        return _QuantLib.YoYOptionletVolatilitySurface_observationLag(self)

    def frequency(self):
        return _QuantLib.YoYOptionletVolatilitySurface_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.YoYOptionletVolatilitySurface_indexIsInterpolated(self)

    def baseDate(self):
        return _QuantLib.YoYOptionletVolatilitySurface_baseDate(self)

    def timeFromBase(self, *args):
        return _QuantLib.YoYOptionletVolatilitySurface_timeFromBase(self, *args)

    def minStrike(self):
        return _QuantLib.YoYOptionletVolatilitySurface_minStrike(self)

    def maxStrike(self):
        return _QuantLib.YoYOptionletVolatilitySurface_maxStrike(self)

    def baseLevel(self):
        return _QuantLib.YoYOptionletVolatilitySurface_baseLevel(self)

    def volatility(self, *args):
        return _QuantLib.YoYOptionletVolatilitySurface_volatility(self, *args)

    def totalVariance(self, *args):
        return _QuantLib.YoYOptionletVolatilitySurface_totalVariance(self, *args)
    __swig_destroy__ = _QuantLib.delete_YoYOptionletVolatilitySurface

# Register YoYOptionletVolatilitySurface in _QuantLib:
_QuantLib.YoYOptionletVolatilitySurface_swigregister(YoYOptionletVolatilitySurface)

class YoYOptionletVolatilitySurfaceHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YoYOptionletVolatilitySurfaceHandle_swiginit(self, _QuantLib.new_YoYOptionletVolatilitySurfaceHandle(*args))

    def __deref__(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YoYOptionletVolatilitySurfaceHandle

    def observationLag(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_observationLag(self)

    def frequency(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated(self)

    def baseDate(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_baseDate(self)

    def timeFromBase(self, *args):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_timeFromBase(self, *args)

    def minStrike(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_maxStrike(self)

    def baseLevel(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_baseLevel(self)

    def volatility(self, *args):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_volatility(self, *args)

    def totalVariance(self, *args):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_totalVariance(self, *args)

    def dayCounter(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation(self)

# Register YoYOptionletVolatilitySurfaceHandle in _QuantLib:
_QuantLib.YoYOptionletVolatilitySurfaceHandle_swigregister(YoYOptionletVolatilitySurfaceHandle)

class RelinkableYoYOptionletVolatilitySurface(YoYOptionletVolatilitySurfaceHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableYoYOptionletVolatilitySurface_swiginit(self, _QuantLib.new_RelinkableYoYOptionletVolatilitySurface(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableYoYOptionletVolatilitySurface_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableYoYOptionletVolatilitySurface_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableYoYOptionletVolatilitySurface

# Register RelinkableYoYOptionletVolatilitySurface in _QuantLib:
_QuantLib.RelinkableYoYOptionletVolatilitySurface_swigregister(RelinkableYoYOptionletVolatilitySurface)

class SmileSection(Observable):
    thisown = 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 minStrike(self):
        return _QuantLib.SmileSection_minStrike(self)

    def maxStrike(self):
        return _QuantLib.SmileSection_maxStrike(self)

    def atmLevel(self):
        return _QuantLib.SmileSection_atmLevel(self)

    def variance(self, strike):
        return _QuantLib.SmileSection_variance(self, strike)

    def exerciseDate(self):
        return _QuantLib.SmileSection_exerciseDate(self)

    def volatilityType(self):
        return _QuantLib.SmileSection_volatilityType(self)

    def shift(self):
        return _QuantLib.SmileSection_shift(self)

    def referenceDate(self):
        return _QuantLib.SmileSection_referenceDate(self)

    def exerciseTime(self):
        return _QuantLib.SmileSection_exerciseTime(self)

    def dayCounter(self):
        return _QuantLib.SmileSection_dayCounter(self)

    def optionPrice(self, *args):
        return _QuantLib.SmileSection_optionPrice(self, *args)

    def digitalOptionPrice(self, *args):
        return _QuantLib.SmileSection_digitalOptionPrice(self, *args)

    def vega(self, strike, discount=1.0):
        return _QuantLib.SmileSection_vega(self, strike, discount)

    def density(self, strike, discount=1.0, gap=1.0E-4):
        return _QuantLib.SmileSection_density(self, strike, discount, gap)

    def volatility(self, *args):
        return _QuantLib.SmileSection_volatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_SmileSection

# Register SmileSection in _QuantLib:
_QuantLib.SmileSection_swigregister(SmileSection)

class SmileSectionVector(object):
    thisown = 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.SmileSectionVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.SmileSectionVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.SmileSectionVector___bool__(self)

    def __len__(self):
        return _QuantLib.SmileSectionVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.SmileSectionVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.SmileSectionVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.SmileSectionVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.SmileSectionVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.SmileSectionVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.SmileSectionVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.SmileSectionVector_pop(self)

    def append(self, x):
        return _QuantLib.SmileSectionVector_append(self, x)

    def empty(self):
        return _QuantLib.SmileSectionVector_empty(self)

    def size(self):
        return _QuantLib.SmileSectionVector_size(self)

    def swap(self, v):
        return _QuantLib.SmileSectionVector_swap(self, v)

    def begin(self):
        return _QuantLib.SmileSectionVector_begin(self)

    def end(self):
        return _QuantLib.SmileSectionVector_end(self)

    def rbegin(self):
        return _QuantLib.SmileSectionVector_rbegin(self)

    def rend(self):
        return _QuantLib.SmileSectionVector_rend(self)

    def clear(self):
        return _QuantLib.SmileSectionVector_clear(self)

    def get_allocator(self):
        return _QuantLib.SmileSectionVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.SmileSectionVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.SmileSectionVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.SmileSectionVector_swiginit(self, _QuantLib.new_SmileSectionVector(*args))

    def push_back(self, x):
        return _QuantLib.SmileSectionVector_push_back(self, x)

    def front(self):
        return _QuantLib.SmileSectionVector_front(self)

    def back(self):
        return _QuantLib.SmileSectionVector_back(self)

    def assign(self, n, x):
        return _QuantLib.SmileSectionVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.SmileSectionVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.SmileSectionVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.SmileSectionVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.SmileSectionVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_SmileSectionVector

# Register SmileSectionVector in _QuantLib:
_QuantLib.SmileSectionVector_swigregister(SmileSectionVector)

class SwaptionVolatilityStructure(VolatilityTermStructure):
    thisown = 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 volatility(self, *args):
        return _QuantLib.SwaptionVolatilityStructure_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.SwaptionVolatilityStructure_blackVariance(self, *args)

    def optionDateFromTenor(self, p):
        return _QuantLib.SwaptionVolatilityStructure_optionDateFromTenor(self, p)

    def shift(self, *args):
        return _QuantLib.SwaptionVolatilityStructure_shift(self, *args)

    def smileSection(self, *args):
        return _QuantLib.SwaptionVolatilityStructure_smileSection(self, *args)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructure

# Register SwaptionVolatilityStructure in _QuantLib:
_QuantLib.SwaptionVolatilityStructure_swigregister(SwaptionVolatilityStructure)

class SwaptionVolatilityStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SwaptionVolatilityStructureHandle_swiginit(self, _QuantLib.new_SwaptionVolatilityStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.SwaptionVolatilityStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.SwaptionVolatilityStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.SwaptionVolatilityStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructureHandle

    def volatility(self, *args):
        return _QuantLib.SwaptionVolatilityStructureHandle_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.SwaptionVolatilityStructureHandle_blackVariance(self, *args)

    def optionDateFromTenor(self, p):
        return _QuantLib.SwaptionVolatilityStructureHandle_optionDateFromTenor(self, p)

    def shift(self, *args):
        return _QuantLib.SwaptionVolatilityStructureHandle_shift(self, *args)

    def smileSection(self, *args):
        return _QuantLib.SwaptionVolatilityStructureHandle_smileSection(self, *args)

    def minStrike(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_maxStrike(self)

    def dayCounter(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.SwaptionVolatilityStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_allowsExtrapolation(self)

# Register SwaptionVolatilityStructureHandle in _QuantLib:
_QuantLib.SwaptionVolatilityStructureHandle_swigregister(SwaptionVolatilityStructureHandle)

class RelinkableSwaptionVolatilityStructureHandle(SwaptionVolatilityStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableSwaptionVolatilityStructureHandle_swiginit(self, _QuantLib.new_RelinkableSwaptionVolatilityStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableSwaptionVolatilityStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableSwaptionVolatilityStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableSwaptionVolatilityStructureHandle

# Register RelinkableSwaptionVolatilityStructureHandle in _QuantLib:
_QuantLib.RelinkableSwaptionVolatilityStructureHandle_swigregister(RelinkableSwaptionVolatilityStructureHandle)

class BlackConstantVol(BlackVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BlackConstantVol_swiginit(self, _QuantLib.new_BlackConstantVol(*args))
    __swig_destroy__ = _QuantLib.delete_BlackConstantVol

# Register BlackConstantVol in _QuantLib:
_QuantLib.BlackConstantVol_swigregister(BlackConstantVol)

class BlackVarianceCurve(BlackVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, referenceDate, dates, volatilities, dayCounter, forceMonotoneVariance=True):
        _QuantLib.BlackVarianceCurve_swiginit(self, _QuantLib.new_BlackVarianceCurve(referenceDate, dates, volatilities, dayCounter, forceMonotoneVariance))
    __swig_destroy__ = _QuantLib.delete_BlackVarianceCurve

# Register BlackVarianceCurve in _QuantLib:
_QuantLib.BlackVarianceCurve_swigregister(BlackVarianceCurve)

class BlackVarianceSurface(BlackVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ConstantExtrapolation = _QuantLib.BlackVarianceSurface_ConstantExtrapolation
    InterpolatorDefaultExtrapolation = _QuantLib.BlackVarianceSurface_InterpolatorDefaultExtrapolation

    def __init__(self, *args, **kwargs):
        _QuantLib.BlackVarianceSurface_swiginit(self, _QuantLib.new_BlackVarianceSurface(*args, **kwargs))

    def setInterpolation(self, *args):
        return _QuantLib.BlackVarianceSurface_setInterpolation(self, *args)
    __swig_destroy__ = _QuantLib.delete_BlackVarianceSurface

# Register BlackVarianceSurface in _QuantLib:
_QuantLib.BlackVarianceSurface_swigregister(BlackVarianceSurface)

class LocalConstantVol(LocalVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LocalConstantVol_swiginit(self, _QuantLib.new_LocalConstantVol(*args))
    __swig_destroy__ = _QuantLib.delete_LocalConstantVol

# Register LocalConstantVol in _QuantLib:
_QuantLib.LocalConstantVol_swigregister(LocalConstantVol)

class LocalVolSurface(LocalVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LocalVolSurface_swiginit(self, _QuantLib.new_LocalVolSurface(*args))
    __swig_destroy__ = _QuantLib.delete_LocalVolSurface

# Register LocalVolSurface in _QuantLib:
_QuantLib.LocalVolSurface_swigregister(LocalVolSurface)

class NoExceptLocalVolSurface(LocalVolSurface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NoExceptLocalVolSurface_swiginit(self, _QuantLib.new_NoExceptLocalVolSurface(*args))
    __swig_destroy__ = _QuantLib.delete_NoExceptLocalVolSurface

# Register NoExceptLocalVolSurface in _QuantLib:
_QuantLib.NoExceptLocalVolSurface_swigregister(NoExceptLocalVolSurface)

class ConstantOptionletVolatility(OptionletVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ConstantOptionletVolatility_swiginit(self, _QuantLib.new_ConstantOptionletVolatility(*args))
    __swig_destroy__ = _QuantLib.delete_ConstantOptionletVolatility

# Register ConstantOptionletVolatility in _QuantLib:
_QuantLib.ConstantOptionletVolatility_swigregister(ConstantOptionletVolatility)

class ConstantSwaptionVolatility(SwaptionVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ConstantSwaptionVolatility_swiginit(self, _QuantLib.new_ConstantSwaptionVolatility(*args))
    __swig_destroy__ = _QuantLib.delete_ConstantSwaptionVolatility

# Register ConstantSwaptionVolatility in _QuantLib:
_QuantLib.ConstantSwaptionVolatility_swigregister(ConstantSwaptionVolatility)

class SwaptionVolatilityDiscrete(SwaptionVolatilityStructure):
    thisown = 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 optionTenors(self):
        return _QuantLib.SwaptionVolatilityDiscrete_optionTenors(self)

    def optionDates(self):
        return _QuantLib.SwaptionVolatilityDiscrete_optionDates(self)

    def optionTimes(self):
        return _QuantLib.SwaptionVolatilityDiscrete_optionTimes(self)

    def swapTenors(self):
        return _QuantLib.SwaptionVolatilityDiscrete_swapTenors(self)

    def swapLengths(self):
        return _QuantLib.SwaptionVolatilityDiscrete_swapLengths(self)

    def optionDateFromTime(self, optionTime):
        return _QuantLib.SwaptionVolatilityDiscrete_optionDateFromTime(self, optionTime)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityDiscrete

# Register SwaptionVolatilityDiscrete in _QuantLib:
_QuantLib.SwaptionVolatilityDiscrete_swigregister(SwaptionVolatilityDiscrete)

class SwaptionVolatilityMatrix(SwaptionVolatilityDiscrete):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SwaptionVolatilityMatrix_swiginit(self, _QuantLib.new_SwaptionVolatilityMatrix(*args))

    def locate(self, *args):
        return _QuantLib.SwaptionVolatilityMatrix_locate(self, *args)

    def volatilityType(self):
        return _QuantLib.SwaptionVolatilityMatrix_volatilityType(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityMatrix

# Register SwaptionVolatilityMatrix in _QuantLib:
_QuantLib.SwaptionVolatilityMatrix_swigregister(SwaptionVolatilityMatrix)

class SabrSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SabrSmileSection_swiginit(self, _QuantLib.new_SabrSmileSection(*args))

    def alpha(self):
        return _QuantLib.SabrSmileSection_alpha(self)

    def beta(self):
        return _QuantLib.SabrSmileSection_beta(self)

    def nu(self):
        return _QuantLib.SabrSmileSection_nu(self)

    def rho(self):
        return _QuantLib.SabrSmileSection_rho(self)
    __swig_destroy__ = _QuantLib.delete_SabrSmileSection

# Register SabrSmileSection in _QuantLib:
_QuantLib.SabrSmileSection_swigregister(SabrSmileSection)

class SwaptionVolatilityCube(SwaptionVolatilityDiscrete):
    thisown = 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 atmStrike(self, optionDate, swapTenor):
        return _QuantLib.SwaptionVolatilityCube_atmStrike(self, optionDate, swapTenor)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityCube

# Register SwaptionVolatilityCube in _QuantLib:
_QuantLib.SwaptionVolatilityCube_swigregister(SwaptionVolatilityCube)

class SwaptionVolCube1(SwaptionVolatilityCube):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SwaptionVolCube1_swiginit(self, _QuantLib.new_SwaptionVolCube1(*args))

    def sparseSabrParameters(self):
        return _QuantLib.SwaptionVolCube1_sparseSabrParameters(self)

    def denseSabrParameters(self):
        return _QuantLib.SwaptionVolCube1_denseSabrParameters(self)

    def marketVolCube(self):
        return _QuantLib.SwaptionVolCube1_marketVolCube(self)

    def volCubeAtmCalibrated(self):
        return _QuantLib.SwaptionVolCube1_volCubeAtmCalibrated(self)

    def smileSection(self, *args):
        return _QuantLib.SwaptionVolCube1_smileSection(self, *args)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolCube1

# Register SwaptionVolCube1 in _QuantLib:
_QuantLib.SwaptionVolCube1_swigregister(SwaptionVolCube1)

class SwaptionVolCube2(SwaptionVolatilityCube):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndex, shortSwapIndex, vegaWeightedSmileFit):
        _QuantLib.SwaptionVolCube2_swiginit(self, _QuantLib.new_SwaptionVolCube2(atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndex, shortSwapIndex, vegaWeightedSmileFit))
    __swig_destroy__ = _QuantLib.delete_SwaptionVolCube2

# Register SwaptionVolCube2 in _QuantLib:
_QuantLib.SwaptionVolCube2_swigregister(SwaptionVolCube2)

class ConstantYoYOptionletVolatility(YoYOptionletVolatilitySurface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, volatility, settlementDays, cal, bdc, dc, observationLag, frequency, indexIsInterpolated, minStrike=-1.0, maxStrike=100.0):
        _QuantLib.ConstantYoYOptionletVolatility_swiginit(self, _QuantLib.new_ConstantYoYOptionletVolatility(volatility, settlementDays, cal, bdc, dc, observationLag, frequency, indexIsInterpolated, minStrike, maxStrike))
    __swig_destroy__ = _QuantLib.delete_ConstantYoYOptionletVolatility

# Register ConstantYoYOptionletVolatility in _QuantLib:
_QuantLib.ConstantYoYOptionletVolatility_swigregister(ConstantYoYOptionletVolatility)

class FlatSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FlatSmileSection_swiginit(self, _QuantLib.new_FlatSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_FlatSmileSection

# Register FlatSmileSection in _QuantLib:
_QuantLib.FlatSmileSection_swigregister(FlatSmileSection)

class LinearInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LinearInterpolatedSmileSection_swiginit(self, _QuantLib.new_LinearInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_LinearInterpolatedSmileSection

# Register LinearInterpolatedSmileSection in _QuantLib:
_QuantLib.LinearInterpolatedSmileSection_swigregister(LinearInterpolatedSmileSection)

class CubicInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CubicInterpolatedSmileSection_swiginit(self, _QuantLib.new_CubicInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_CubicInterpolatedSmileSection

# Register CubicInterpolatedSmileSection in _QuantLib:
_QuantLib.CubicInterpolatedSmileSection_swigregister(CubicInterpolatedSmileSection)

class MonotonicCubicInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MonotonicCubicInterpolatedSmileSection_swiginit(self, _QuantLib.new_MonotonicCubicInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicInterpolatedSmileSection

# Register MonotonicCubicInterpolatedSmileSection in _QuantLib:
_QuantLib.MonotonicCubicInterpolatedSmileSection_swigregister(MonotonicCubicInterpolatedSmileSection)

class SplineCubicInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SplineCubicInterpolatedSmileSection_swiginit(self, _QuantLib.new_SplineCubicInterpolatedSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_SplineCubicInterpolatedSmileSection

# Register SplineCubicInterpolatedSmileSection in _QuantLib:
_QuantLib.SplineCubicInterpolatedSmileSection_swigregister(SplineCubicInterpolatedSmileSection)

class KahaleSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.KahaleSmileSection_swiginit(self, _QuantLib.new_KahaleSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_KahaleSmileSection

# Register KahaleSmileSection in _QuantLib:
_QuantLib.KahaleSmileSection_swigregister(KahaleSmileSection)

class ZabrShortMaturityLognormal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ZabrShortMaturityLognormal_swiginit(self, _QuantLib.new_ZabrShortMaturityLognormal())
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityLognormal

# Register ZabrShortMaturityLognormal in _QuantLib:
_QuantLib.ZabrShortMaturityLognormal_swigregister(ZabrShortMaturityLognormal)

class ZabrShortMaturityNormal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ZabrShortMaturityNormal_swiginit(self, _QuantLib.new_ZabrShortMaturityNormal())
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityNormal

# Register ZabrShortMaturityNormal in _QuantLib:
_QuantLib.ZabrShortMaturityNormal_swigregister(ZabrShortMaturityNormal)

class ZabrLocalVolatility(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ZabrLocalVolatility_swiginit(self, _QuantLib.new_ZabrLocalVolatility())
    __swig_destroy__ = _QuantLib.delete_ZabrLocalVolatility

# Register ZabrLocalVolatility in _QuantLib:
_QuantLib.ZabrLocalVolatility_swigregister(ZabrLocalVolatility)

class ZabrFullFd(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ZabrFullFd_swiginit(self, _QuantLib.new_ZabrFullFd())
    __swig_destroy__ = _QuantLib.delete_ZabrFullFd

# Register ZabrFullFd in _QuantLib:
_QuantLib.ZabrFullFd_swigregister(ZabrFullFd)

class ZabrShortMaturityLognormalSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrShortMaturityLognormalSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityLognormalSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityLognormalSmileSection

# Register ZabrShortMaturityLognormalSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityLognormalSmileSection_swigregister(ZabrShortMaturityLognormalSmileSection)

class ZabrShortMaturityNormalSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrShortMaturityNormalSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityNormalSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityNormalSmileSection

# Register ZabrShortMaturityNormalSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityNormalSmileSection_swigregister(ZabrShortMaturityNormalSmileSection)

class ZabrLocalVolatilitySmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrLocalVolatilitySmileSection_swiginit(self, _QuantLib.new_ZabrLocalVolatilitySmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrLocalVolatilitySmileSection

# Register ZabrLocalVolatilitySmileSection in _QuantLib:
_QuantLib.ZabrLocalVolatilitySmileSection_swigregister(ZabrLocalVolatilitySmileSection)

class ZabrFullFdSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrFullFdSmileSection_swiginit(self, _QuantLib.new_ZabrFullFdSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_ZabrFullFdSmileSection

# Register ZabrFullFdSmileSection in _QuantLib:
_QuantLib.ZabrFullFdSmileSection_swigregister(ZabrFullFdSmileSection)

class ZabrShortMaturityLognormalInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityLognormalInterpolatedSmileSection(*args))

    def alpha(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_alpha(self)

    def beta(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_beta(self)

    def nu(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_nu(self)

    def rho(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_rho(self)

    def rmsError(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        return _QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityLognormalInterpolatedSmileSection

# Register ZabrShortMaturityLognormalInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister(ZabrShortMaturityLognormalInterpolatedSmileSection)

class ZabrShortMaturityNormalInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrShortMaturityNormalInterpolatedSmileSection(*args))

    def alpha(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_alpha(self)

    def beta(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_beta(self)

    def nu(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_nu(self)

    def rho(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_rho(self)

    def rmsError(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        return _QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrShortMaturityNormalInterpolatedSmileSection

# Register ZabrShortMaturityNormalInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrShortMaturityNormalInterpolatedSmileSection_swigregister(ZabrShortMaturityNormalInterpolatedSmileSection)

class ZabrLocalVolatilityInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrLocalVolatilityInterpolatedSmileSection(*args))

    def alpha(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_alpha(self)

    def beta(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_beta(self)

    def nu(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_nu(self)

    def rho(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_rho(self)

    def rmsError(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        return _QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrLocalVolatilityInterpolatedSmileSection

# Register ZabrLocalVolatilityInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrLocalVolatilityInterpolatedSmileSection_swigregister(ZabrLocalVolatilityInterpolatedSmileSection)

class ZabrFullFdInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZabrFullFdInterpolatedSmileSection_swiginit(self, _QuantLib.new_ZabrFullFdInterpolatedSmileSection(*args))

    def alpha(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_alpha(self)

    def beta(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_beta(self)

    def nu(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_nu(self)

    def rho(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_rho(self)

    def rmsError(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        return _QuantLib.ZabrFullFdInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_ZabrFullFdInterpolatedSmileSection

# Register ZabrFullFdInterpolatedSmileSection in _QuantLib:
_QuantLib.ZabrFullFdInterpolatedSmileSection_swigregister(ZabrFullFdInterpolatedSmileSection)

class NoArbSabrSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NoArbSabrSmileSection_swiginit(self, _QuantLib.new_NoArbSabrSmileSection(*args))
    __swig_destroy__ = _QuantLib.delete_NoArbSabrSmileSection

# Register NoArbSabrSmileSection in _QuantLib:
_QuantLib.NoArbSabrSmileSection_swigregister(NoArbSabrSmileSection)

class NoArbSabrInterpolatedSmileSection(SmileSection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NoArbSabrInterpolatedSmileSection_swiginit(self, _QuantLib.new_NoArbSabrInterpolatedSmileSection(*args))

    def alpha(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_alpha(self)

    def beta(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_beta(self)

    def nu(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_nu(self)

    def rho(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_rho(self)

    def rmsError(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_rmsError(self)

    def maxError(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_maxError(self)

    def endCriteria(self):
        return _QuantLib.NoArbSabrInterpolatedSmileSection_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_NoArbSabrInterpolatedSmileSection

# Register NoArbSabrInterpolatedSmileSection in _QuantLib:
_QuantLib.NoArbSabrInterpolatedSmileSection_swigregister(NoArbSabrInterpolatedSmileSection)


def sabrVolatility(strike, forward, expiryTime, alpha, beta, nu, rho):
    return _QuantLib.sabrVolatility(strike, forward, expiryTime, alpha, beta, nu, rho)

def shiftedSabrVolatility(strike, forward, expiryTime, alpha, beta, nu, rho, shift):
    return _QuantLib.shiftedSabrVolatility(strike, forward, expiryTime, alpha, beta, nu, rho, shift)

def sabrFlochKennedyVolatility(strike, forward, expiryTime, alpha, beta, nu, rho):
    return _QuantLib.sabrFlochKennedyVolatility(strike, forward, expiryTime, alpha, beta, nu, rho)
class CalibrationErrorTuple(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg3, arg4):
        _QuantLib.CalibrationErrorTuple_swiginit(self, _QuantLib.new_CalibrationErrorTuple(arg2, arg3, arg4))

    def first(self):
        return _QuantLib.CalibrationErrorTuple_first(self)

    def second(self):
        return _QuantLib.CalibrationErrorTuple_second(self)

    def third(self):
        return _QuantLib.CalibrationErrorTuple_third(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationErrorTuple

# Register CalibrationErrorTuple in _QuantLib:
_QuantLib.CalibrationErrorTuple_swigregister(CalibrationErrorTuple)

class AndreasenHugeVolatilityInterpl(Observable):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PiecewiseConstant = _QuantLib.AndreasenHugeVolatilityInterpl_PiecewiseConstant
    Linear = _QuantLib.AndreasenHugeVolatilityInterpl_Linear
    CubicSpline = _QuantLib.AndreasenHugeVolatilityInterpl_CubicSpline
    Call = _QuantLib.AndreasenHugeVolatilityInterpl_Call
    Put = _QuantLib.AndreasenHugeVolatilityInterpl_Put
    CallPut = _QuantLib.AndreasenHugeVolatilityInterpl_CallPut

    def __init__(self, *args):
        _QuantLib.AndreasenHugeVolatilityInterpl_swiginit(self, _QuantLib.new_AndreasenHugeVolatilityInterpl(*args))

    def maxDate(self):
        return _QuantLib.AndreasenHugeVolatilityInterpl_maxDate(self)

    def minStrike(self):
        return _QuantLib.AndreasenHugeVolatilityInterpl_minStrike(self)

    def maxStrike(self):
        return _QuantLib.AndreasenHugeVolatilityInterpl_maxStrike(self)

    def fwd(self, t):
        return _QuantLib.AndreasenHugeVolatilityInterpl_fwd(self, t)

    def riskFreeRate(self):
        return _QuantLib.AndreasenHugeVolatilityInterpl_riskFreeRate(self)

    def calibrationError(self):
        return _QuantLib.AndreasenHugeVolatilityInterpl_calibrationError(self)

    def optionPrice(self, t, strike, optionType):
        return _QuantLib.AndreasenHugeVolatilityInterpl_optionPrice(self, t, strike, optionType)

    def localVol(self, t, strike):
        return _QuantLib.AndreasenHugeVolatilityInterpl_localVol(self, t, strike)
    __swig_destroy__ = _QuantLib.delete_AndreasenHugeVolatilityInterpl

# Register AndreasenHugeVolatilityInterpl in _QuantLib:
_QuantLib.AndreasenHugeVolatilityInterpl_swigregister(AndreasenHugeVolatilityInterpl)

class AndreasenHugeVolatilityAdapter(BlackVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, volInterpl, eps=1e-6):
        _QuantLib.AndreasenHugeVolatilityAdapter_swiginit(self, _QuantLib.new_AndreasenHugeVolatilityAdapter(volInterpl, eps))
    __swig_destroy__ = _QuantLib.delete_AndreasenHugeVolatilityAdapter

# Register AndreasenHugeVolatilityAdapter in _QuantLib:
_QuantLib.AndreasenHugeVolatilityAdapter_swigregister(AndreasenHugeVolatilityAdapter)

class AndreasenHugeLocalVolAdapter(LocalVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, localVol):
        _QuantLib.AndreasenHugeLocalVolAdapter_swiginit(self, _QuantLib.new_AndreasenHugeLocalVolAdapter(localVol))
    __swig_destroy__ = _QuantLib.delete_AndreasenHugeLocalVolAdapter

# Register AndreasenHugeLocalVolAdapter in _QuantLib:
_QuantLib.AndreasenHugeLocalVolAdapter_swigregister(AndreasenHugeLocalVolAdapter)

class HestonBlackVolSurface(BlackVolTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HestonBlackVolSurface_swiginit(self, _QuantLib.new_HestonBlackVolSurface(*args))
    __swig_destroy__ = _QuantLib.delete_HestonBlackVolSurface

# Register HestonBlackVolSurface in _QuantLib:
_QuantLib.HestonBlackVolSurface_swigregister(HestonBlackVolSurface)

class CmsMarket(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, swapLengths, swapIndexes, iborIndex, bidAskSpreads, pricers, discountingTS):
        _QuantLib.CmsMarket_swiginit(self, _QuantLib.new_CmsMarket(swapLengths, swapIndexes, iborIndex, bidAskSpreads, pricers, discountingTS))

    def reprice(self, volStructure, meanReversion):
        return _QuantLib.CmsMarket_reprice(self, volStructure, meanReversion)

    def swapTenors(self):
        return _QuantLib.CmsMarket_swapTenors(self)

    def swapLengths(self):
        return _QuantLib.CmsMarket_swapLengths(self)

    def impliedCmsSpreads(self):
        return _QuantLib.CmsMarket_impliedCmsSpreads(self)

    def spreadErrors(self):
        return _QuantLib.CmsMarket_spreadErrors(self)

    def browse(self):
        return _QuantLib.CmsMarket_browse(self)

    def weightedSpreadError(self, weights):
        return _QuantLib.CmsMarket_weightedSpreadError(self, weights)

    def weightedSpotNpvError(self, weights):
        return _QuantLib.CmsMarket_weightedSpotNpvError(self, weights)

    def weightedFwdNpvError(self, weights):
        return _QuantLib.CmsMarket_weightedFwdNpvError(self, weights)

    def weightedSpreadErrors(self, weights):
        return _QuantLib.CmsMarket_weightedSpreadErrors(self, weights)

    def weightedSpotNpvErrors(self, weights):
        return _QuantLib.CmsMarket_weightedSpotNpvErrors(self, weights)

    def weightedFwdNpvErrors(self, weights):
        return _QuantLib.CmsMarket_weightedFwdNpvErrors(self, weights)
    __swig_destroy__ = _QuantLib.delete_CmsMarket

# Register CmsMarket in _QuantLib:
_QuantLib.CmsMarket_swigregister(CmsMarket)

class CmsMarketCalibration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    OnSpread = _QuantLib.CmsMarketCalibration_OnSpread
    OnPrice = _QuantLib.CmsMarketCalibration_OnPrice
    OnForwardCmsPrice = _QuantLib.CmsMarketCalibration_OnForwardCmsPrice

    def __init__(self, volCube, cmsMarket, weights, calibrationType):
        _QuantLib.CmsMarketCalibration_swiginit(self, _QuantLib.new_CmsMarketCalibration(volCube, cmsMarket, weights, calibrationType))

    def compute(self, *args):
        return _QuantLib.CmsMarketCalibration_compute(self, *args)

    def computeParametric(self, *args):
        return _QuantLib.CmsMarketCalibration_computeParametric(self, *args)

    def error(self):
        return _QuantLib.CmsMarketCalibration_error(self)

    def endCriteria(self):
        return _QuantLib.CmsMarketCalibration_endCriteria(self)
    __swig_destroy__ = _QuantLib.delete_CmsMarketCalibration

# Register CmsMarketCalibration in _QuantLib:
_QuantLib.CmsMarketCalibration_swigregister(CmsMarketCalibration)

class StochasticProcess(Observable):
    thisown = 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 size(self):
        return _QuantLib.StochasticProcess_size(self)

    def factors(self):
        return _QuantLib.StochasticProcess_factors(self)

    def initialValues(self):
        return _QuantLib.StochasticProcess_initialValues(self)

    def drift(self, t, x):
        return _QuantLib.StochasticProcess_drift(self, t, x)

    def diffusion(self, t, x):
        return _QuantLib.StochasticProcess_diffusion(self, t, x)

    def expectation(self, t0, x0, dt):
        return _QuantLib.StochasticProcess_expectation(self, t0, x0, dt)

    def stdDeviation(self, t0, x0, dt):
        return _QuantLib.StochasticProcess_stdDeviation(self, t0, x0, dt)

    def covariance(self, t0, x0, dt):
        return _QuantLib.StochasticProcess_covariance(self, t0, x0, dt)

    def evolve(self, t0, x0, dt, dw):
        return _QuantLib.StochasticProcess_evolve(self, t0, x0, dt, dw)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess

# Register StochasticProcess in _QuantLib:
_QuantLib.StochasticProcess_swigregister(StochasticProcess)

class StochasticProcessVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.StochasticProcessVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.StochasticProcessVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.StochasticProcessVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.StochasticProcessVector_pop(self)

    def append(self, x):
        return _QuantLib.StochasticProcessVector_append(self, x)

    def empty(self):
        return _QuantLib.StochasticProcessVector_empty(self)

    def size(self):
        return _QuantLib.StochasticProcessVector_size(self)

    def swap(self, v):
        return _QuantLib.StochasticProcessVector_swap(self, v)

    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 clear(self):
        return _QuantLib.StochasticProcessVector_clear(self)

    def get_allocator(self):
        return _QuantLib.StochasticProcessVector_get_allocator(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):
        _QuantLib.StochasticProcessVector_swiginit(self, _QuantLib.new_StochasticProcessVector(*args))

    def push_back(self, x):
        return _QuantLib.StochasticProcessVector_push_back(self, x)

    def front(self):
        return _QuantLib.StochasticProcessVector_front(self)

    def back(self):
        return _QuantLib.StochasticProcessVector_back(self)

    def assign(self, n, x):
        return _QuantLib.StochasticProcessVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.StochasticProcessVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.StochasticProcessVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.StochasticProcessVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.StochasticProcessVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StochasticProcessVector

# Register StochasticProcessVector in _QuantLib:
_QuantLib.StochasticProcessVector_swigregister(StochasticProcessVector)

class StochasticProcess1D(StochasticProcess):
    thisown = 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 x0(self):
        return _QuantLib.StochasticProcess1D_x0(self)

    def drift(self, t, x):
        return _QuantLib.StochasticProcess1D_drift(self, t, x)

    def diffusion(self, t, x):
        return _QuantLib.StochasticProcess1D_diffusion(self, t, x)

    def expectation(self, t0, x0, dt):
        return _QuantLib.StochasticProcess1D_expectation(self, t0, x0, dt)

    def stdDeviation(self, t0, x0, dt):
        return _QuantLib.StochasticProcess1D_stdDeviation(self, t0, x0, dt)

    def variance(self, t0, x0, dt):
        return _QuantLib.StochasticProcess1D_variance(self, t0, x0, dt)

    def evolve(self, t0, x0, dt, dw):
        return _QuantLib.StochasticProcess1D_evolve(self, t0, x0, dt, dw)

    def apply(self, x0, dx):
        return _QuantLib.StochasticProcess1D_apply(self, x0, dx)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess1D

# Register StochasticProcess1D in _QuantLib:
_QuantLib.StochasticProcess1D_swigregister(StochasticProcess1D)

class StochasticProcess1DVector(object):
    thisown = 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.StochasticProcess1DVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.StochasticProcess1DVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.StochasticProcess1DVector___bool__(self)

    def __len__(self):
        return _QuantLib.StochasticProcess1DVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.StochasticProcess1DVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.StochasticProcess1DVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.StochasticProcess1DVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.StochasticProcess1DVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.StochasticProcess1DVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.StochasticProcess1DVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.StochasticProcess1DVector_pop(self)

    def append(self, x):
        return _QuantLib.StochasticProcess1DVector_append(self, x)

    def empty(self):
        return _QuantLib.StochasticProcess1DVector_empty(self)

    def size(self):
        return _QuantLib.StochasticProcess1DVector_size(self)

    def swap(self, v):
        return _QuantLib.StochasticProcess1DVector_swap(self, v)

    def begin(self):
        return _QuantLib.StochasticProcess1DVector_begin(self)

    def end(self):
        return _QuantLib.StochasticProcess1DVector_end(self)

    def rbegin(self):
        return _QuantLib.StochasticProcess1DVector_rbegin(self)

    def rend(self):
        return _QuantLib.StochasticProcess1DVector_rend(self)

    def clear(self):
        return _QuantLib.StochasticProcess1DVector_clear(self)

    def get_allocator(self):
        return _QuantLib.StochasticProcess1DVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.StochasticProcess1DVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.StochasticProcess1DVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.StochasticProcess1DVector_swiginit(self, _QuantLib.new_StochasticProcess1DVector(*args))

    def push_back(self, x):
        return _QuantLib.StochasticProcess1DVector_push_back(self, x)

    def front(self):
        return _QuantLib.StochasticProcess1DVector_front(self)

    def back(self):
        return _QuantLib.StochasticProcess1DVector_back(self)

    def assign(self, n, x):
        return _QuantLib.StochasticProcess1DVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.StochasticProcess1DVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.StochasticProcess1DVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.StochasticProcess1DVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.StochasticProcess1DVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_StochasticProcess1DVector

# Register StochasticProcess1DVector in _QuantLib:
_QuantLib.StochasticProcess1DVector_swigregister(StochasticProcess1DVector)

class GeneralizedBlackScholesProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GeneralizedBlackScholesProcess_swiginit(self, _QuantLib.new_GeneralizedBlackScholesProcess(*args))

    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

# Register GeneralizedBlackScholesProcess in _QuantLib:
_QuantLib.GeneralizedBlackScholesProcess_swigregister(GeneralizedBlackScholesProcess)

class BlackScholesProcess(GeneralizedBlackScholesProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s0, riskFreeTS, volTS):
        _QuantLib.BlackScholesProcess_swiginit(self, _QuantLib.new_BlackScholesProcess(s0, riskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_BlackScholesProcess

# Register BlackScholesProcess in _QuantLib:
_QuantLib.BlackScholesProcess_swigregister(BlackScholesProcess)

class BlackScholesMertonProcess(GeneralizedBlackScholesProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s0, dividendTS, riskFreeTS, volTS):
        _QuantLib.BlackScholesMertonProcess_swiginit(self, _QuantLib.new_BlackScholesMertonProcess(s0, dividendTS, riskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_BlackScholesMertonProcess

# Register BlackScholesMertonProcess in _QuantLib:
_QuantLib.BlackScholesMertonProcess_swigregister(BlackScholesMertonProcess)

class BlackProcess(GeneralizedBlackScholesProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s0, riskFreeTS, volTS):
        _QuantLib.BlackProcess_swiginit(self, _QuantLib.new_BlackProcess(s0, riskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_BlackProcess

# Register BlackProcess in _QuantLib:
_QuantLib.BlackProcess_swigregister(BlackProcess)

class GarmanKohlagenProcess(GeneralizedBlackScholesProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s0, foreignRiskFreeTS, domesticRiskFreeTS, volTS):
        _QuantLib.GarmanKohlagenProcess_swiginit(self, _QuantLib.new_GarmanKohlagenProcess(s0, foreignRiskFreeTS, domesticRiskFreeTS, volTS))
    __swig_destroy__ = _QuantLib.delete_GarmanKohlagenProcess

# Register GarmanKohlagenProcess in _QuantLib:
_QuantLib.GarmanKohlagenProcess_swigregister(GarmanKohlagenProcess)

class Merton76Process(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, stateVariable, dividendTS, riskFreeTS, volTS, jumpIntensity, meanLogJump, jumpVolatility):
        _QuantLib.Merton76Process_swiginit(self, _QuantLib.new_Merton76Process(stateVariable, dividendTS, riskFreeTS, volTS, jumpIntensity, meanLogJump, jumpVolatility))
    __swig_destroy__ = _QuantLib.delete_Merton76Process

# Register Merton76Process in _QuantLib:
_QuantLib.Merton76Process_swigregister(Merton76Process)

class StochasticProcessArray(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, array, correlation):
        _QuantLib.StochasticProcessArray_swiginit(self, _QuantLib.new_StochasticProcessArray(array, correlation))
    __swig_destroy__ = _QuantLib.delete_StochasticProcessArray

# Register StochasticProcessArray in _QuantLib:
_QuantLib.StochasticProcessArray_swigregister(StochasticProcessArray)

class GeometricBrownianMotionProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, initialValue, mu, sigma):
        _QuantLib.GeometricBrownianMotionProcess_swiginit(self, _QuantLib.new_GeometricBrownianMotionProcess(initialValue, mu, sigma))
    __swig_destroy__ = _QuantLib.delete_GeometricBrownianMotionProcess

# Register GeometricBrownianMotionProcess in _QuantLib:
_QuantLib.GeometricBrownianMotionProcess_swigregister(GeometricBrownianMotionProcess)

class VarianceGammaProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s0, dividendYield, riskFreeRate, sigma, nu, theta):
        _QuantLib.VarianceGammaProcess_swiginit(self, _QuantLib.new_VarianceGammaProcess(s0, dividendYield, riskFreeRate, sigma, nu, theta))
    __swig_destroy__ = _QuantLib.delete_VarianceGammaProcess

# Register VarianceGammaProcess in _QuantLib:
_QuantLib.VarianceGammaProcess_swigregister(VarianceGammaProcess)

class HestonProcess(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PartialTruncation = _QuantLib.HestonProcess_PartialTruncation
    FullTruncation = _QuantLib.HestonProcess_FullTruncation
    Reflection = _QuantLib.HestonProcess_Reflection
    NonCentralChiSquareVariance = _QuantLib.HestonProcess_NonCentralChiSquareVariance
    QuadraticExponential = _QuantLib.HestonProcess_QuadraticExponential
    QuadraticExponentialMartingale = _QuantLib.HestonProcess_QuadraticExponentialMartingale
    BroadieKayaExactSchemeLobatto = _QuantLib.HestonProcess_BroadieKayaExactSchemeLobatto
    BroadieKayaExactSchemeLaguerre = _QuantLib.HestonProcess_BroadieKayaExactSchemeLaguerre
    BroadieKayaExactSchemeTrapezoidal = _QuantLib.HestonProcess_BroadieKayaExactSchemeTrapezoidal

    def __init__(self, *args):
        _QuantLib.HestonProcess_swiginit(self, _QuantLib.new_HestonProcess(*args))

    def s0(self):
        return _QuantLib.HestonProcess_s0(self)

    def dividendYield(self):
        return _QuantLib.HestonProcess_dividendYield(self)

    def riskFreeRate(self):
        return _QuantLib.HestonProcess_riskFreeRate(self)
    __swig_destroy__ = _QuantLib.delete_HestonProcess

# Register HestonProcess in _QuantLib:
_QuantLib.HestonProcess_swigregister(HestonProcess)

class BatesProcess(HestonProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, riskFreeRate, dividendYield, s0, v0, kappa, theta, sigma, rho, lambda_parameter, nu, delta):
        _QuantLib.BatesProcess_swiginit(self, _QuantLib.new_BatesProcess(riskFreeRate, dividendYield, s0, v0, kappa, theta, sigma, rho, lambda_parameter, nu, delta))
    __swig_destroy__ = _QuantLib.delete_BatesProcess

# Register BatesProcess in _QuantLib:
_QuantLib.BatesProcess_swigregister(BatesProcess)

class HullWhiteProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, riskFreeTS, a, sigma):
        _QuantLib.HullWhiteProcess_swiginit(self, _QuantLib.new_HullWhiteProcess(riskFreeTS, a, sigma))
    __swig_destroy__ = _QuantLib.delete_HullWhiteProcess

# Register HullWhiteProcess in _QuantLib:
_QuantLib.HullWhiteProcess_swigregister(HullWhiteProcess)

class HullWhiteForwardProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, riskFreeTS, a, sigma):
        _QuantLib.HullWhiteForwardProcess_swiginit(self, _QuantLib.new_HullWhiteForwardProcess(riskFreeTS, a, sigma))

    def alpha(self, t):
        return _QuantLib.HullWhiteForwardProcess_alpha(self, t)

    def M_T(self, s, t, T):
        return _QuantLib.HullWhiteForwardProcess_M_T(self, s, t, T)

    def B(self, t, T):
        return _QuantLib.HullWhiteForwardProcess_B(self, t, T)

    def setForwardMeasureTime(self, t):
        return _QuantLib.HullWhiteForwardProcess_setForwardMeasureTime(self, t)
    __swig_destroy__ = _QuantLib.delete_HullWhiteForwardProcess

# Register HullWhiteForwardProcess in _QuantLib:
_QuantLib.HullWhiteForwardProcess_swigregister(HullWhiteForwardProcess)

class G2Process(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, a, sigma, b, eta, rho):
        _QuantLib.G2Process_swiginit(self, _QuantLib.new_G2Process(a, sigma, b, eta, rho))
    __swig_destroy__ = _QuantLib.delete_G2Process

# Register G2Process in _QuantLib:
_QuantLib.G2Process_swigregister(G2Process)

class G2ForwardProcess(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, a, sigma, b, eta, rho):
        _QuantLib.G2ForwardProcess_swiginit(self, _QuantLib.new_G2ForwardProcess(a, sigma, b, eta, rho))

    def setForwardMeasureTime(self, t):
        return _QuantLib.G2ForwardProcess_setForwardMeasureTime(self, t)
    __swig_destroy__ = _QuantLib.delete_G2ForwardProcess

# Register G2ForwardProcess in _QuantLib:
_QuantLib.G2ForwardProcess_swigregister(G2ForwardProcess)

class GsrProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, times, vols, reversions, T=60.0):
        _QuantLib.GsrProcess_swiginit(self, _QuantLib.new_GsrProcess(times, vols, reversions, T))

    def sigma(self, t):
        return _QuantLib.GsrProcess_sigma(self, t)

    def reversion(self, t):
        return _QuantLib.GsrProcess_reversion(self, t)

    def y(self, t):
        return _QuantLib.GsrProcess_y(self, t)

    def G(self, t, T, x):
        return _QuantLib.GsrProcess_G(self, t, T, x)

    def setForwardMeasureTime(self, t):
        return _QuantLib.GsrProcess_setForwardMeasureTime(self, t)
    __swig_destroy__ = _QuantLib.delete_GsrProcess

# Register GsrProcess in _QuantLib:
_QuantLib.GsrProcess_swigregister(GsrProcess)


def as_gsr_process(proc):
    return _QuantLib.as_gsr_process(proc)
class OrnsteinUhlenbeckProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, speed, vol, x0=0.0, level=0.0):
        _QuantLib.OrnsteinUhlenbeckProcess_swiginit(self, _QuantLib.new_OrnsteinUhlenbeckProcess(speed, vol, x0, level))

    def speed(self):
        return _QuantLib.OrnsteinUhlenbeckProcess_speed(self)

    def volatility(self):
        return _QuantLib.OrnsteinUhlenbeckProcess_volatility(self)

    def level(self):
        return _QuantLib.OrnsteinUhlenbeckProcess_level(self)
    __swig_destroy__ = _QuantLib.delete_OrnsteinUhlenbeckProcess

# Register OrnsteinUhlenbeckProcess in _QuantLib:
_QuantLib.OrnsteinUhlenbeckProcess_swigregister(OrnsteinUhlenbeckProcess)

class ExtendedOrnsteinUhlenbeckProcess(StochasticProcess1D):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MidPoint = _QuantLib.ExtendedOrnsteinUhlenbeckProcess_MidPoint
    Trapezodial = _QuantLib.ExtendedOrnsteinUhlenbeckProcess_Trapezodial
    GaussLobatto = _QuantLib.ExtendedOrnsteinUhlenbeckProcess_GaussLobatto

    def __init__(self, *args):
        _QuantLib.ExtendedOrnsteinUhlenbeckProcess_swiginit(self, _QuantLib.new_ExtendedOrnsteinUhlenbeckProcess(*args))
    __swig_destroy__ = _QuantLib.delete_ExtendedOrnsteinUhlenbeckProcess

# Register ExtendedOrnsteinUhlenbeckProcess in _QuantLib:
_QuantLib.ExtendedOrnsteinUhlenbeckProcess_swigregister(ExtendedOrnsteinUhlenbeckProcess)

class ExtOUWithJumpsProcess(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, Y0, beta, jumpIntensity, eta):
        _QuantLib.ExtOUWithJumpsProcess_swiginit(self, _QuantLib.new_ExtOUWithJumpsProcess(process, Y0, beta, jumpIntensity, eta))
    __swig_destroy__ = _QuantLib.delete_ExtOUWithJumpsProcess

# Register ExtOUWithJumpsProcess in _QuantLib:
_QuantLib.ExtOUWithJumpsProcess_swigregister(ExtOUWithJumpsProcess)

class KlugeExtOUProcess(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho, kluge, extOU):
        _QuantLib.KlugeExtOUProcess_swiginit(self, _QuantLib.new_KlugeExtOUProcess(rho, kluge, extOU))
    __swig_destroy__ = _QuantLib.delete_KlugeExtOUProcess

# Register KlugeExtOUProcess in _QuantLib:
_QuantLib.KlugeExtOUProcess_swigregister(KlugeExtOUProcess)

class GJRGARCHProcess(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PartialTruncation = _QuantLib.GJRGARCHProcess_PartialTruncation
    FullTruncation = _QuantLib.GJRGARCHProcess_FullTruncation
    Reflection = _QuantLib.GJRGARCHProcess_Reflection

    def __init__(self, *args):
        _QuantLib.GJRGARCHProcess_swiginit(self, _QuantLib.new_GJRGARCHProcess(*args))

    def s0(self):
        return _QuantLib.GJRGARCHProcess_s0(self)

    def dividendYield(self):
        return _QuantLib.GJRGARCHProcess_dividendYield(self)

    def riskFreeRate(self):
        return _QuantLib.GJRGARCHProcess_riskFreeRate(self)
    __swig_destroy__ = _QuantLib.delete_GJRGARCHProcess

# Register GJRGARCHProcess in _QuantLib:
_QuantLib.GJRGARCHProcess_swigregister(GJRGARCHProcess)

class PricingEngine(Observable):
    thisown = 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_PricingEngine

# Register PricingEngine in _QuantLib:
_QuantLib.PricingEngine_swigregister(PricingEngine)

class Instrument(Observable):
    thisown = 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 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, arg2):
        return _QuantLib.Instrument_setPricingEngine(self, arg2)

    def recalculate(self):
        return _QuantLib.Instrument_recalculate(self)

    def freeze(self):
        return _QuantLib.Instrument_freeze(self)

    def unfreeze(self):
        return _QuantLib.Instrument_unfreeze(self)
    __swig_destroy__ = _QuantLib.delete_Instrument

# Register Instrument in _QuantLib:
_QuantLib.Instrument_swigregister(Instrument)

class InstrumentVector(object):
    thisown = 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.InstrumentVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.InstrumentVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.InstrumentVector___bool__(self)

    def __len__(self):
        return _QuantLib.InstrumentVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.InstrumentVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.InstrumentVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.InstrumentVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.InstrumentVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.InstrumentVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.InstrumentVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.InstrumentVector_pop(self)

    def append(self, x):
        return _QuantLib.InstrumentVector_append(self, x)

    def empty(self):
        return _QuantLib.InstrumentVector_empty(self)

    def size(self):
        return _QuantLib.InstrumentVector_size(self)

    def swap(self, v):
        return _QuantLib.InstrumentVector_swap(self, v)

    def begin(self):
        return _QuantLib.InstrumentVector_begin(self)

    def end(self):
        return _QuantLib.InstrumentVector_end(self)

    def rbegin(self):
        return _QuantLib.InstrumentVector_rbegin(self)

    def rend(self):
        return _QuantLib.InstrumentVector_rend(self)

    def clear(self):
        return _QuantLib.InstrumentVector_clear(self)

    def get_allocator(self):
        return _QuantLib.InstrumentVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.InstrumentVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.InstrumentVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.InstrumentVector_swiginit(self, _QuantLib.new_InstrumentVector(*args))

    def push_back(self, x):
        return _QuantLib.InstrumentVector_push_back(self, x)

    def front(self):
        return _QuantLib.InstrumentVector_front(self)

    def back(self):
        return _QuantLib.InstrumentVector_back(self)

    def assign(self, n, x):
        return _QuantLib.InstrumentVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.InstrumentVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.InstrumentVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.InstrumentVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.InstrumentVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_InstrumentVector

# Register InstrumentVector in _QuantLib:
_QuantLib.InstrumentVector_swigregister(InstrumentVector)

class Stock(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, quote):
        _QuantLib.Stock_swiginit(self, _QuantLib.new_Stock(quote))
    __swig_destroy__ = _QuantLib.delete_Stock

# Register Stock in _QuantLib:
_QuantLib.Stock_swigregister(Stock)

class CompositeInstrument(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.CompositeInstrument_swiginit(self, _QuantLib.new_CompositeInstrument())

    def add(self, instrument, multiplier=1.0):
        return _QuantLib.CompositeInstrument_add(self, instrument, multiplier)

    def subtract(self, instrument, multiplier=1.0):
        return _QuantLib.CompositeInstrument_subtract(self, instrument, multiplier)
    __swig_destroy__ = _QuantLib.delete_CompositeInstrument

# Register CompositeInstrument in _QuantLib:
_QuantLib.CompositeInstrument_swigregister(CompositeInstrument)

class DateGeneration(object):
    thisown = 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
    CDS = _QuantLib.DateGeneration_CDS
    CDS2015 = _QuantLib.DateGeneration_CDS2015

    def __init__(self):
        _QuantLib.DateGeneration_swiginit(self, _QuantLib.new_DateGeneration())
    __swig_destroy__ = _QuantLib.delete_DateGeneration

# Register DateGeneration in _QuantLib:
_QuantLib.DateGeneration_swigregister(DateGeneration)

class Schedule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Schedule_swiginit(self, _QuantLib.new_Schedule(*args))

    def __len__(self):
        return _QuantLib.Schedule___len__(self)

    def previousDate(self, refDate):
        return _QuantLib.Schedule_previousDate(self, refDate)

    def nextDate(self, refDate):
        return _QuantLib.Schedule_nextDate(self, refDate)

    def hasIsRegular(self):
        return _QuantLib.Schedule_hasIsRegular(self)

    def isRegular(self, *args):
        return _QuantLib.Schedule_isRegular(self, *args)

    def calendar(self):
        return _QuantLib.Schedule_calendar(self)

    def startDate(self):
        return _QuantLib.Schedule_startDate(self)

    def endDate(self):
        return _QuantLib.Schedule_endDate(self)

    def hasTenor(self):
        return _QuantLib.Schedule_hasTenor(self)

    def tenor(self):
        return _QuantLib.Schedule_tenor(self)

    def businessDayConvention(self):
        return _QuantLib.Schedule_businessDayConvention(self)

    def hasTerminationDateBusinessDayConvention(self):
        return _QuantLib.Schedule_hasTerminationDateBusinessDayConvention(self)

    def terminationDateBusinessDayConvention(self):
        return _QuantLib.Schedule_terminationDateBusinessDayConvention(self)

    def hasRule(self):
        return _QuantLib.Schedule_hasRule(self)

    def rule(self):
        return _QuantLib.Schedule_rule(self)

    def hasEndOfMonth(self):
        return _QuantLib.Schedule_hasEndOfMonth(self)

    def endOfMonth(self):
        return _QuantLib.Schedule_endOfMonth(self)

    def until(self, truncationDate):
        return _QuantLib.Schedule_until(self, truncationDate)

    def __getitem__(self, i):
        return _QuantLib.Schedule___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_Schedule

# Register Schedule in _QuantLib:
_QuantLib.Schedule_swigregister(Schedule)

class _MakeSchedule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib._MakeSchedule_swiginit(self, _QuantLib.new__MakeSchedule())

    def fromDate(self, effectiveDate):
        return _QuantLib._MakeSchedule_fromDate(self, effectiveDate)

    def to(self, terminationDate):
        return _QuantLib._MakeSchedule_to(self, terminationDate)

    def withTenor(self, arg2):
        return _QuantLib._MakeSchedule_withTenor(self, arg2)

    def withFrequency(self, arg2):
        return _QuantLib._MakeSchedule_withFrequency(self, arg2)

    def withCalendar(self, arg2):
        return _QuantLib._MakeSchedule_withCalendar(self, arg2)

    def withConvention(self, arg2):
        return _QuantLib._MakeSchedule_withConvention(self, arg2)

    def withTerminationDateConvention(self, arg2):
        return _QuantLib._MakeSchedule_withTerminationDateConvention(self, arg2)

    def withRule(self, arg2):
        return _QuantLib._MakeSchedule_withRule(self, arg2)

    def forwards(self):
        return _QuantLib._MakeSchedule_forwards(self)

    def backwards(self):
        return _QuantLib._MakeSchedule_backwards(self)

    def endOfMonth(self, flag=True):
        return _QuantLib._MakeSchedule_endOfMonth(self, flag)

    def withFirstDate(self, d):
        return _QuantLib._MakeSchedule_withFirstDate(self, d)

    def withNextToLastDate(self, d):
        return _QuantLib._MakeSchedule_withNextToLastDate(self, d)

    def schedule(self):
        return _QuantLib._MakeSchedule_schedule(self)
    __swig_destroy__ = _QuantLib.delete__MakeSchedule

# Register _MakeSchedule in _QuantLib:
_QuantLib._MakeSchedule_swigregister(_MakeSchedule)


def MakeSchedule(effectiveDate=None,terminationDate=None,tenor=None,
    frequency=None,calendar=None,convention=None,terminalDateConvention=None,
    rule=None,forwards=False,backwards=False,
    endOfMonth=None,firstDate=None,nextToLastDate=None):
    ms = _MakeSchedule()
    if effectiveDate is not None:
        ms.fromDate(effectiveDate)
    if terminationDate is not None:
        ms.to(terminationDate)
    if tenor is not None:
        ms.withTenor(tenor)
    if frequency is not None:
        ms.withFrequency(frequency)
    if calendar is not None:
        ms.withCalendar(calendar)
    if convention is not None:
        ms.withConvention(convention)
    if terminalDateConvention is not None:
        ms.withTerminationDateConvention(terminalDateConvention)
    if rule is not None:
        ms.withRule(rule)
    if forwards:
        ms.forwards()
    if backwards:
        ms.backwards()
    if endOfMonth is not None:
        ms.endOfMonth(endOfMonth)
    if firstDate is not None:
        ms.withFirstDate(firstDate)
    if nextToLastDate is not None:
        ms.withNextToLastDate(nextToLastDate)
    return ms.schedule()

class CashFlow(Observable):
    thisown = 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 amount(self):
        return _QuantLib.CashFlow_amount(self)

    def date(self):
        return _QuantLib.CashFlow_date(self)

    def hasOccurred(self, *args):
        return _QuantLib.CashFlow_hasOccurred(self, *args)
    __swig_destroy__ = _QuantLib.delete_CashFlow

# Register CashFlow in _QuantLib:
_QuantLib.CashFlow_swigregister(CashFlow)

class Leg(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.Leg___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.Leg___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.Leg___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.Leg_pop(self)

    def append(self, x):
        return _QuantLib.Leg_append(self, x)

    def empty(self):
        return _QuantLib.Leg_empty(self)

    def size(self):
        return _QuantLib.Leg_size(self)

    def swap(self, v):
        return _QuantLib.Leg_swap(self, v)

    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 clear(self):
        return _QuantLib.Leg_clear(self)

    def get_allocator(self):
        return _QuantLib.Leg_get_allocator(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):
        _QuantLib.Leg_swiginit(self, _QuantLib.new_Leg(*args))

    def push_back(self, x):
        return _QuantLib.Leg_push_back(self, x)

    def front(self):
        return _QuantLib.Leg_front(self)

    def back(self):
        return _QuantLib.Leg_back(self)

    def assign(self, n, x):
        return _QuantLib.Leg_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.Leg_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.Leg_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.Leg_reserve(self, n)

    def capacity(self):
        return _QuantLib.Leg_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Leg

# Register Leg in _QuantLib:
_QuantLib.Leg_swigregister(Leg)

class SimpleCashFlow(CashFlow):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        _QuantLib.SimpleCashFlow_swiginit(self, _QuantLib.new_SimpleCashFlow(amount, date))
    __swig_destroy__ = _QuantLib.delete_SimpleCashFlow

# Register SimpleCashFlow in _QuantLib:
_QuantLib.SimpleCashFlow_swigregister(SimpleCashFlow)

class Redemption(CashFlow):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        _QuantLib.Redemption_swiginit(self, _QuantLib.new_Redemption(amount, date))
    __swig_destroy__ = _QuantLib.delete_Redemption

# Register Redemption in _QuantLib:
_QuantLib.Redemption_swigregister(Redemption)

class AmortizingPayment(CashFlow):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        _QuantLib.AmortizingPayment_swiginit(self, _QuantLib.new_AmortizingPayment(amount, date))
    __swig_destroy__ = _QuantLib.delete_AmortizingPayment

# Register AmortizingPayment in _QuantLib:
_QuantLib.AmortizingPayment_swigregister(AmortizingPayment)

class IndexedCashFlow(CashFlow):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, notional, index, baseDate, fixingDate, paymentDate, growthOnly=False):
        _QuantLib.IndexedCashFlow_swiginit(self, _QuantLib.new_IndexedCashFlow(notional, index, baseDate, fixingDate, paymentDate, growthOnly))

    def notional(self):
        return _QuantLib.IndexedCashFlow_notional(self)

    def baseDate(self):
        return _QuantLib.IndexedCashFlow_baseDate(self)

    def fixingDate(self):
        return _QuantLib.IndexedCashFlow_fixingDate(self)

    def index(self):
        return _QuantLib.IndexedCashFlow_index(self)

    def growthOnly(self):
        return _QuantLib.IndexedCashFlow_growthOnly(self)
    __swig_destroy__ = _QuantLib.delete_IndexedCashFlow

# Register IndexedCashFlow in _QuantLib:
_QuantLib.IndexedCashFlow_swigregister(IndexedCashFlow)


def as_indexed_cashflow(cf):
    return _QuantLib.as_indexed_cashflow(cf)
class Coupon(CashFlow):
    thisown = 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 nominal(self):
        return _QuantLib.Coupon_nominal(self)

    def accrualStartDate(self):
        return _QuantLib.Coupon_accrualStartDate(self)

    def accrualEndDate(self):
        return _QuantLib.Coupon_accrualEndDate(self)

    def referencePeriodStart(self):
        return _QuantLib.Coupon_referencePeriodStart(self)

    def referencePeriodEnd(self):
        return _QuantLib.Coupon_referencePeriodEnd(self)

    def exCouponDate(self):
        return _QuantLib.Coupon_exCouponDate(self)

    def rate(self):
        return _QuantLib.Coupon_rate(self)

    def accrualPeriod(self):
        return _QuantLib.Coupon_accrualPeriod(self)

    def accrualDays(self):
        return _QuantLib.Coupon_accrualDays(self)

    def dayCounter(self):
        return _QuantLib.Coupon_dayCounter(self)

    def accruedAmount(self, date):
        return _QuantLib.Coupon_accruedAmount(self, date)
    __swig_destroy__ = _QuantLib.delete_Coupon

# Register Coupon in _QuantLib:
_QuantLib.Coupon_swigregister(Coupon)


def as_coupon(cf):
    return _QuantLib.as_coupon(cf)
class FixedRateCoupon(Coupon):
    thisown = 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):
        _QuantLib.FixedRateCoupon_swiginit(self, _QuantLib.new_FixedRateCoupon(*args, **kwargs))

    def interestRate(self):
        return _QuantLib.FixedRateCoupon_interestRate(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateCoupon

# Register FixedRateCoupon in _QuantLib:
_QuantLib.FixedRateCoupon_swigregister(FixedRateCoupon)


def as_fixed_rate_coupon(cf):
    return _QuantLib.as_fixed_rate_coupon(cf)
class FloatingRateCouponPricer(object):
    thisown = 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 swapletPrice(self):
        return _QuantLib.FloatingRateCouponPricer_swapletPrice(self)

    def swapletRate(self):
        return _QuantLib.FloatingRateCouponPricer_swapletRate(self)

    def capletPrice(self, effectiveCap):
        return _QuantLib.FloatingRateCouponPricer_capletPrice(self, effectiveCap)

    def capletRate(self, effectiveCap):
        return _QuantLib.FloatingRateCouponPricer_capletRate(self, effectiveCap)

    def floorletPrice(self, effectiveFloor):
        return _QuantLib.FloatingRateCouponPricer_floorletPrice(self, effectiveFloor)

    def floorletRate(self, effectiveFloor):
        return _QuantLib.FloatingRateCouponPricer_floorletRate(self, effectiveFloor)
    __swig_destroy__ = _QuantLib.delete_FloatingRateCouponPricer

# Register FloatingRateCouponPricer in _QuantLib:
_QuantLib.FloatingRateCouponPricer_swigregister(FloatingRateCouponPricer)


def setCouponPricer(arg1, arg2):
    return _QuantLib.setCouponPricer(arg1, arg2)
class FloatingRateCoupon(Coupon):
    thisown = 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 fixingDate(self):
        return _QuantLib.FloatingRateCoupon_fixingDate(self)

    def fixingDays(self):
        return _QuantLib.FloatingRateCoupon_fixingDays(self)

    def isInArrears(self):
        return _QuantLib.FloatingRateCoupon_isInArrears(self)

    def gearing(self):
        return _QuantLib.FloatingRateCoupon_gearing(self)

    def spread(self):
        return _QuantLib.FloatingRateCoupon_spread(self)

    def indexFixing(self):
        return _QuantLib.FloatingRateCoupon_indexFixing(self)

    def adjustedFixing(self):
        return _QuantLib.FloatingRateCoupon_adjustedFixing(self)

    def convexityAdjustment(self):
        return _QuantLib.FloatingRateCoupon_convexityAdjustment(self)

    def price(self, discountCurve):
        return _QuantLib.FloatingRateCoupon_price(self, discountCurve)

    def index(self):
        return _QuantLib.FloatingRateCoupon_index(self)

    def setPricer(self, p):
        return _QuantLib.FloatingRateCoupon_setPricer(self, p)
    __swig_destroy__ = _QuantLib.delete_FloatingRateCoupon

# Register FloatingRateCoupon in _QuantLib:
_QuantLib.FloatingRateCoupon_swigregister(FloatingRateCoupon)


def as_floating_rate_coupon(cf):
    return _QuantLib.as_floating_rate_coupon(cf)
class OvernightIndexedCoupon(FloatingRateCoupon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.OvernightIndexedCoupon_swiginit(self, _QuantLib.new_OvernightIndexedCoupon(*args))

    def fixingDates(self):
        return _QuantLib.OvernightIndexedCoupon_fixingDates(self)

    def dt(self):
        return _QuantLib.OvernightIndexedCoupon_dt(self)

    def indexFixings(self):
        return _QuantLib.OvernightIndexedCoupon_indexFixings(self)

    def valueDates(self):
        return _QuantLib.OvernightIndexedCoupon_valueDates(self)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexedCoupon

# Register OvernightIndexedCoupon in _QuantLib:
_QuantLib.OvernightIndexedCoupon_swigregister(OvernightIndexedCoupon)

class CappedFlooredCoupon(FloatingRateCoupon):
    thisown = 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):
        _QuantLib.CappedFlooredCoupon_swiginit(self, _QuantLib.new_CappedFlooredCoupon(*args, **kwargs))

    def cap(self):
        return _QuantLib.CappedFlooredCoupon_cap(self)

    def floor(self):
        return _QuantLib.CappedFlooredCoupon_floor(self)

    def effectiveCap(self):
        return _QuantLib.CappedFlooredCoupon_effectiveCap(self)

    def effectiveFloor(self):
        return _QuantLib.CappedFlooredCoupon_effectiveFloor(self)

    def isCapped(self):
        return _QuantLib.CappedFlooredCoupon_isCapped(self)

    def isFloored(self):
        return _QuantLib.CappedFlooredCoupon_isFloored(self)

    def setPricer(self, p):
        return _QuantLib.CappedFlooredCoupon_setPricer(self, p)
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCoupon

# Register CappedFlooredCoupon in _QuantLib:
_QuantLib.CappedFlooredCoupon_swigregister(CappedFlooredCoupon)

class IborCoupon(FloatingRateCoupon):
    thisown = 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):
        _QuantLib.IborCoupon_swiginit(self, _QuantLib.new_IborCoupon(*args, **kwargs))

    @staticmethod
    def createAtParCoupons():
        return _QuantLib.IborCoupon_createAtParCoupons()

    @staticmethod
    def createIndexedCoupons():
        return _QuantLib.IborCoupon_createIndexedCoupons()

    @staticmethod
    def usingAtParCoupons():
        return _QuantLib.IborCoupon_usingAtParCoupons()
    __swig_destroy__ = _QuantLib.delete_IborCoupon

# Register IborCoupon in _QuantLib:
_QuantLib.IborCoupon_swigregister(IborCoupon)

def IborCoupon_createAtParCoupons():
    return _QuantLib.IborCoupon_createAtParCoupons()

def IborCoupon_createIndexedCoupons():
    return _QuantLib.IborCoupon_createIndexedCoupons()

def IborCoupon_usingAtParCoupons():
    return _QuantLib.IborCoupon_usingAtParCoupons()

class CappedFlooredIborCoupon(CappedFlooredCoupon):
    thisown = 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):
        _QuantLib.CappedFlooredIborCoupon_swiginit(self, _QuantLib.new_CappedFlooredIborCoupon(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CappedFlooredIborCoupon

# Register CappedFlooredIborCoupon in _QuantLib:
_QuantLib.CappedFlooredIborCoupon_swigregister(CappedFlooredIborCoupon)

class IborCouponPricer(FloatingRateCouponPricer):
    thisown = 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 capletVolatility(self):
        return _QuantLib.IborCouponPricer_capletVolatility(self)

    def setCapletVolatility(self, *args):
        return _QuantLib.IborCouponPricer_setCapletVolatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_IborCouponPricer

# Register IborCouponPricer in _QuantLib:
_QuantLib.IborCouponPricer_swigregister(IborCouponPricer)

class BlackIborCouponPricer(IborCouponPricer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Black76 = _QuantLib.BlackIborCouponPricer_Black76
    BivariateLognormal = _QuantLib.BlackIborCouponPricer_BivariateLognormal

    def __init__(self, *args):
        _QuantLib.BlackIborCouponPricer_swiginit(self, _QuantLib.new_BlackIborCouponPricer(*args))
    __swig_destroy__ = _QuantLib.delete_BlackIborCouponPricer

# Register BlackIborCouponPricer in _QuantLib:
_QuantLib.BlackIborCouponPricer_swigregister(BlackIborCouponPricer)

class CmsCoupon(FloatingRateCoupon):
    thisown = 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):
        _QuantLib.CmsCoupon_swiginit(self, _QuantLib.new_CmsCoupon(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CmsCoupon

# Register CmsCoupon in _QuantLib:
_QuantLib.CmsCoupon_swigregister(CmsCoupon)

class CmsSpreadCoupon(FloatingRateCoupon):
    thisown = 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):
        _QuantLib.CmsSpreadCoupon_swiginit(self, _QuantLib.new_CmsSpreadCoupon(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CmsSpreadCoupon

# Register CmsSpreadCoupon in _QuantLib:
_QuantLib.CmsSpreadCoupon_swigregister(CmsSpreadCoupon)

class CmsCouponPricer(FloatingRateCouponPricer):
    thisown = 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 swaptionVolatility(self):
        return _QuantLib.CmsCouponPricer_swaptionVolatility(self)

    def setSwaptionVolatility(self, *args):
        return _QuantLib.CmsCouponPricer_setSwaptionVolatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_CmsCouponPricer

# Register CmsCouponPricer in _QuantLib:
_QuantLib.CmsCouponPricer_swigregister(CmsCouponPricer)

class CmsCouponPricerVector(object):
    thisown = 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.CmsCouponPricerVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.CmsCouponPricerVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.CmsCouponPricerVector___bool__(self)

    def __len__(self):
        return _QuantLib.CmsCouponPricerVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.CmsCouponPricerVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.CmsCouponPricerVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.CmsCouponPricerVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.CmsCouponPricerVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.CmsCouponPricerVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.CmsCouponPricerVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.CmsCouponPricerVector_pop(self)

    def append(self, x):
        return _QuantLib.CmsCouponPricerVector_append(self, x)

    def empty(self):
        return _QuantLib.CmsCouponPricerVector_empty(self)

    def size(self):
        return _QuantLib.CmsCouponPricerVector_size(self)

    def swap(self, v):
        return _QuantLib.CmsCouponPricerVector_swap(self, v)

    def begin(self):
        return _QuantLib.CmsCouponPricerVector_begin(self)

    def end(self):
        return _QuantLib.CmsCouponPricerVector_end(self)

    def rbegin(self):
        return _QuantLib.CmsCouponPricerVector_rbegin(self)

    def rend(self):
        return _QuantLib.CmsCouponPricerVector_rend(self)

    def clear(self):
        return _QuantLib.CmsCouponPricerVector_clear(self)

    def get_allocator(self):
        return _QuantLib.CmsCouponPricerVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.CmsCouponPricerVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.CmsCouponPricerVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.CmsCouponPricerVector_swiginit(self, _QuantLib.new_CmsCouponPricerVector(*args))

    def push_back(self, x):
        return _QuantLib.CmsCouponPricerVector_push_back(self, x)

    def front(self):
        return _QuantLib.CmsCouponPricerVector_front(self)

    def back(self):
        return _QuantLib.CmsCouponPricerVector_back(self)

    def assign(self, n, x):
        return _QuantLib.CmsCouponPricerVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.CmsCouponPricerVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.CmsCouponPricerVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.CmsCouponPricerVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.CmsCouponPricerVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CmsCouponPricerVector

# Register CmsCouponPricerVector in _QuantLib:
_QuantLib.CmsCouponPricerVector_swigregister(CmsCouponPricerVector)

class GFunctionFactory(object):
    thisown = 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
    Standard = _QuantLib.GFunctionFactory_Standard
    ExactYield = _QuantLib.GFunctionFactory_ExactYield
    ParallelShifts = _QuantLib.GFunctionFactory_ParallelShifts
    NonParallelShifts = _QuantLib.GFunctionFactory_NonParallelShifts
    __swig_destroy__ = _QuantLib.delete_GFunctionFactory

# Register GFunctionFactory in _QuantLib:
_QuantLib.GFunctionFactory_swigregister(GFunctionFactory)

class AnalyticHaganPricer(CmsCouponPricer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, v, model, meanReversion):
        _QuantLib.AnalyticHaganPricer_swiginit(self, _QuantLib.new_AnalyticHaganPricer(v, model, meanReversion))
    __swig_destroy__ = _QuantLib.delete_AnalyticHaganPricer

# Register AnalyticHaganPricer in _QuantLib:
_QuantLib.AnalyticHaganPricer_swigregister(AnalyticHaganPricer)

class NumericHaganPricer(CmsCouponPricer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, v, model, meanReversion, lowerLimit=0.0, upperLimit=1.0, precision=1.0e-6):
        _QuantLib.NumericHaganPricer_swiginit(self, _QuantLib.new_NumericHaganPricer(v, model, meanReversion, lowerLimit, upperLimit, precision))
    __swig_destroy__ = _QuantLib.delete_NumericHaganPricer

# Register NumericHaganPricer in _QuantLib:
_QuantLib.NumericHaganPricer_swigregister(NumericHaganPricer)

class CappedFlooredCmsCoupon(CappedFlooredCoupon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CappedFlooredCmsCoupon_swiginit(self, _QuantLib.new_CappedFlooredCmsCoupon(*args))
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCmsCoupon

# Register CappedFlooredCmsCoupon in _QuantLib:
_QuantLib.CappedFlooredCmsCoupon_swigregister(CappedFlooredCmsCoupon)

class CappedFlooredCmsSpreadCoupon(CappedFlooredCoupon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CappedFlooredCmsSpreadCoupon_swiginit(self, _QuantLib.new_CappedFlooredCmsSpreadCoupon(*args))
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCmsSpreadCoupon

# Register CappedFlooredCmsSpreadCoupon in _QuantLib:
_QuantLib.CappedFlooredCmsSpreadCoupon_swigregister(CappedFlooredCmsSpreadCoupon)

class LinearTsrPricer(CmsCouponPricer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LinearTsrPricer_swiginit(self, _QuantLib.new_LinearTsrPricer(*args))
    __swig_destroy__ = _QuantLib.delete_LinearTsrPricer

# Register LinearTsrPricer in _QuantLib:
_QuantLib.LinearTsrPricer_swigregister(LinearTsrPricer)

class LinearTsrPricerSettings(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.LinearTsrPricerSettings_swiginit(self, _QuantLib.new_LinearTsrPricerSettings())

    def withRateBound(self, lowerRateBound=0.0001, upperRateBound=2.0000):
        return _QuantLib.LinearTsrPricerSettings_withRateBound(self, lowerRateBound, upperRateBound)

    def withVegaRatio(self, *args):
        return _QuantLib.LinearTsrPricerSettings_withVegaRatio(self, *args)

    def withPriceThreshold(self, *args):
        return _QuantLib.LinearTsrPricerSettings_withPriceThreshold(self, *args)

    def withBSStdDevs(self, *args):
        return _QuantLib.LinearTsrPricerSettings_withBSStdDevs(self, *args)
    RateBound = _QuantLib.LinearTsrPricerSettings_RateBound
    VegaRatio = _QuantLib.LinearTsrPricerSettings_VegaRatio
    PriceThreshold = _QuantLib.LinearTsrPricerSettings_PriceThreshold
    BSStdDevs = _QuantLib.LinearTsrPricerSettings_BSStdDevs
    __swig_destroy__ = _QuantLib.delete_LinearTsrPricerSettings

# Register LinearTsrPricerSettings in _QuantLib:
_QuantLib.LinearTsrPricerSettings_swigregister(LinearTsrPricerSettings)

class CmsSpreadCouponPricer(FloatingRateCouponPricer):
    thisown = 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 correlation(self):
        return _QuantLib.CmsSpreadCouponPricer_correlation(self)

    def setCorrelation(self, *args):
        return _QuantLib.CmsSpreadCouponPricer_setCorrelation(self, *args)
    __swig_destroy__ = _QuantLib.delete_CmsSpreadCouponPricer

# Register CmsSpreadCouponPricer in _QuantLib:
_QuantLib.CmsSpreadCouponPricer_swigregister(CmsSpreadCouponPricer)

class LognormalCmsSpreadPricer(CmsSpreadCouponPricer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LognormalCmsSpreadPricer_swiginit(self, _QuantLib.new_LognormalCmsSpreadPricer(*args))

    def swapletPrice(self):
        return _QuantLib.LognormalCmsSpreadPricer_swapletPrice(self)

    def swapletRate(self):
        return _QuantLib.LognormalCmsSpreadPricer_swapletRate(self)

    def capletPrice(self, effectiveCap):
        return _QuantLib.LognormalCmsSpreadPricer_capletPrice(self, effectiveCap)

    def capletRate(self, effectiveCap):
        return _QuantLib.LognormalCmsSpreadPricer_capletRate(self, effectiveCap)

    def floorletPrice(self, effectiveFloor):
        return _QuantLib.LognormalCmsSpreadPricer_floorletPrice(self, effectiveFloor)

    def floorletRate(self, effectiveFloor):
        return _QuantLib.LognormalCmsSpreadPricer_floorletRate(self, effectiveFloor)
    __swig_destroy__ = _QuantLib.delete_LognormalCmsSpreadPricer

# Register LognormalCmsSpreadPricer in _QuantLib:
_QuantLib.LognormalCmsSpreadPricer_swigregister(LognormalCmsSpreadPricer)


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

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

def OvernightLeg(*args, **kwargs):
    return _QuantLib.OvernightLeg(*args, **kwargs)

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

def CmsZeroLeg(*args, **kwargs):
    return _QuantLib.CmsZeroLeg(*args, **kwargs)

def CmsSpreadLeg(*args, **kwargs):
    return _QuantLib.CmsSpreadLeg(*args, **kwargs)
class Duration(object):
    thisown = 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):
        _QuantLib.Duration_swiginit(self, _QuantLib.new_Duration())
    __swig_destroy__ = _QuantLib.delete_Duration

# Register Duration in _QuantLib:
_QuantLib.Duration_swigregister(Duration)

class CashFlows(object):
    thisown = 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

    @staticmethod
    def startDate(arg1):
        return _QuantLib.CashFlows_startDate(arg1)

    @staticmethod
    def maturityDate(arg1):
        return _QuantLib.CashFlows_maturityDate(arg1)

    @staticmethod
    def previousCashFlowDate(*args):
        return _QuantLib.CashFlows_previousCashFlowDate(*args)

    @staticmethod
    def nextCashFlowDate(*args):
        return _QuantLib.CashFlows_nextCashFlowDate(*args)

    @staticmethod
    def previousCashFlow(*args):
        return _QuantLib.CashFlows_previousCashFlow(*args)

    @staticmethod
    def nextCashFlow(*args):
        return _QuantLib.CashFlows_nextCashFlow(*args)

    @staticmethod
    def npv(*args):
        return _QuantLib.CashFlows_npv(*args)

    @staticmethod
    def bps(*args):
        return _QuantLib.CashFlows_bps(*args)

    @staticmethod
    def atmRate(*args):
        return _QuantLib.CashFlows_atmRate(*args)

    @staticmethod
    def yieldRate(*args):
        return _QuantLib.CashFlows_yieldRate(*args)

    @staticmethod
    def duration(*args):
        return _QuantLib.CashFlows_duration(*args)

    @staticmethod
    def convexity(*args):
        return _QuantLib.CashFlows_convexity(*args)

    @staticmethod
    def basisPointValue(*args):
        return _QuantLib.CashFlows_basisPointValue(*args)

    @staticmethod
    def zSpread(*args):
        return _QuantLib.CashFlows_zSpread(*args)
    __swig_destroy__ = _QuantLib.delete_CashFlows

# Register CashFlows in _QuantLib:
_QuantLib.CashFlows_swigregister(CashFlows)

def CashFlows_startDate(arg1):
    return _QuantLib.CashFlows_startDate(arg1)

def CashFlows_maturityDate(arg1):
    return _QuantLib.CashFlows_maturityDate(arg1)

def CashFlows_previousCashFlowDate(*args):
    return _QuantLib.CashFlows_previousCashFlowDate(*args)

def CashFlows_nextCashFlowDate(*args):
    return _QuantLib.CashFlows_nextCashFlowDate(*args)

def CashFlows_previousCashFlow(*args):
    return _QuantLib.CashFlows_previousCashFlow(*args)

def CashFlows_nextCashFlow(*args):
    return _QuantLib.CashFlows_nextCashFlow(*args)

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

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

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

def CashFlows_yieldRate(*args):
    return _QuantLib.CashFlows_yieldRate(*args)

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

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

def CashFlows_basisPointValue(*args):
    return _QuantLib.CashFlows_basisPointValue(*args)

def CashFlows_zSpread(*args):
    return _QuantLib.CashFlows_zSpread(*args)

class CalibrationHelper(object):
    thisown = 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 calibrationError(self):
        return _QuantLib.CalibrationHelper_calibrationError(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationHelper

# Register CalibrationHelper in _QuantLib:
_QuantLib.CalibrationHelper_swigregister(CalibrationHelper)

class BlackCalibrationHelper(CalibrationHelper):
    thisown = 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
    RelativePriceError = _QuantLib.BlackCalibrationHelper_RelativePriceError
    PriceError = _QuantLib.BlackCalibrationHelper_PriceError
    ImpliedVolError = _QuantLib.BlackCalibrationHelper_ImpliedVolError

    def setPricingEngine(self, engine):
        return _QuantLib.BlackCalibrationHelper_setPricingEngine(self, engine)

    def marketValue(self):
        return _QuantLib.BlackCalibrationHelper_marketValue(self)

    def modelValue(self):
        return _QuantLib.BlackCalibrationHelper_modelValue(self)

    def impliedVolatility(self, targetValue, accuracy, maxEvaluations, minVol, maxVol):
        return _QuantLib.BlackCalibrationHelper_impliedVolatility(self, targetValue, accuracy, maxEvaluations, minVol, maxVol)

    def blackPrice(self, volatility):
        return _QuantLib.BlackCalibrationHelper_blackPrice(self, volatility)

    def volatility(self):
        return _QuantLib.BlackCalibrationHelper_volatility(self)

    def volatilityType(self):
        return _QuantLib.BlackCalibrationHelper_volatilityType(self)

    def calibrationError(self):
        return _QuantLib.BlackCalibrationHelper_calibrationError(self)
    __swig_destroy__ = _QuantLib.delete_BlackCalibrationHelper

# Register BlackCalibrationHelper in _QuantLib:
_QuantLib.BlackCalibrationHelper_swigregister(BlackCalibrationHelper)


def as_black_helper(h):
    return _QuantLib.as_black_helper(h)

def as_swaption_helper(h):
    return _QuantLib.as_swaption_helper(h)
class SwaptionHelper(BlackCalibrationHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SwaptionHelper_swiginit(self, _QuantLib.new_SwaptionHelper(*args))

    def underlyingSwap(self):
        return _QuantLib.SwaptionHelper_underlyingSwap(self)

    def swaption(self):
        return _QuantLib.SwaptionHelper_swaption(self)

    def times(self):
        return _QuantLib.SwaptionHelper_times(self)

    def swaptionExpiryDate(self):
        return _QuantLib.SwaptionHelper_swaptionExpiryDate(self)

    def swaptionStrike(self):
        return _QuantLib.SwaptionHelper_swaptionStrike(self)

    def swaptionNominal(self):
        return _QuantLib.SwaptionHelper_swaptionNominal(self)

    def swaptionMaturityDate(self):
        return _QuantLib.SwaptionHelper_swaptionMaturityDate(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionHelper

# Register SwaptionHelper in _QuantLib:
_QuantLib.SwaptionHelper_swigregister(SwaptionHelper)

class CapHelper(BlackCalibrationHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CapHelper_swiginit(self, _QuantLib.new_CapHelper(*args))

    def times(self):
        return _QuantLib.CapHelper_times(self)
    __swig_destroy__ = _QuantLib.delete_CapHelper

# Register CapHelper in _QuantLib:
_QuantLib.CapHelper_swigregister(CapHelper)

class HestonModelHelper(BlackCalibrationHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HestonModelHelper_swiginit(self, _QuantLib.new_HestonModelHelper(*args))
    __swig_destroy__ = _QuantLib.delete_HestonModelHelper

# Register HestonModelHelper in _QuantLib:
_QuantLib.HestonModelHelper_swigregister(HestonModelHelper)

class CalibrationHelperVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.CalibrationHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.CalibrationHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.CalibrationHelperVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.CalibrationHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.CalibrationHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.CalibrationHelperVector_empty(self)

    def size(self):
        return _QuantLib.CalibrationHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.CalibrationHelperVector_swap(self, v)

    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 clear(self):
        return _QuantLib.CalibrationHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.CalibrationHelperVector_get_allocator(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):
        _QuantLib.CalibrationHelperVector_swiginit(self, _QuantLib.new_CalibrationHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.CalibrationHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.CalibrationHelperVector_front(self)

    def back(self):
        return _QuantLib.CalibrationHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.CalibrationHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.CalibrationHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.CalibrationHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.CalibrationHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.CalibrationHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationHelperVector

# Register CalibrationHelperVector in _QuantLib:
_QuantLib.CalibrationHelperVector_swigregister(CalibrationHelperVector)

class BlackCalibrationHelperVector(object):
    thisown = 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.BlackCalibrationHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.BlackCalibrationHelperVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.BlackCalibrationHelperVector___bool__(self)

    def __len__(self):
        return _QuantLib.BlackCalibrationHelperVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.BlackCalibrationHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.BlackCalibrationHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.BlackCalibrationHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.BlackCalibrationHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.BlackCalibrationHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.BlackCalibrationHelperVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.BlackCalibrationHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.BlackCalibrationHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.BlackCalibrationHelperVector_empty(self)

    def size(self):
        return _QuantLib.BlackCalibrationHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.BlackCalibrationHelperVector_swap(self, v)

    def begin(self):
        return _QuantLib.BlackCalibrationHelperVector_begin(self)

    def end(self):
        return _QuantLib.BlackCalibrationHelperVector_end(self)

    def rbegin(self):
        return _QuantLib.BlackCalibrationHelperVector_rbegin(self)

    def rend(self):
        return _QuantLib.BlackCalibrationHelperVector_rend(self)

    def clear(self):
        return _QuantLib.BlackCalibrationHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.BlackCalibrationHelperVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.BlackCalibrationHelperVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.BlackCalibrationHelperVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.BlackCalibrationHelperVector_swiginit(self, _QuantLib.new_BlackCalibrationHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.BlackCalibrationHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.BlackCalibrationHelperVector_front(self)

    def back(self):
        return _QuantLib.BlackCalibrationHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.BlackCalibrationHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.BlackCalibrationHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.BlackCalibrationHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.BlackCalibrationHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.BlackCalibrationHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_BlackCalibrationHelperVector

# Register BlackCalibrationHelperVector in _QuantLib:
_QuantLib.BlackCalibrationHelperVector_swigregister(BlackCalibrationHelperVector)

class CalibratedModel(Observable):
    thisown = 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 params(self):
        return _QuantLib.CalibratedModel_params(self)

    def calibrate(self, *args):
        return _QuantLib.CalibratedModel_calibrate(self, *args)

    def setParams(self, params):
        return _QuantLib.CalibratedModel_setParams(self, params)

    def value(self, params, arg3):
        return _QuantLib.CalibratedModel_value(self, params, arg3)

    def constraint(self):
        return _QuantLib.CalibratedModel_constraint(self)

    def endCriteria(self):
        return _QuantLib.CalibratedModel_endCriteria(self)

    def problemValues(self):
        return _QuantLib.CalibratedModel_problemValues(self)

    def functionEvaluation(self):
        return _QuantLib.CalibratedModel_functionEvaluation(self)
    __swig_destroy__ = _QuantLib.delete_CalibratedModel

# Register CalibratedModel in _QuantLib:
_QuantLib.CalibratedModel_swigregister(CalibratedModel)

class TermStructureConsistentModel(Observable):
    thisown = 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 termStructure(self):
        return _QuantLib.TermStructureConsistentModel_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_TermStructureConsistentModel

# Register TermStructureConsistentModel in _QuantLib:
_QuantLib.TermStructureConsistentModel_swigregister(TermStructureConsistentModel)

class CalibratedModelHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CalibratedModelHandle_swiginit(self, _QuantLib.new_CalibratedModelHandle(*args))

    def __deref__(self):
        return _QuantLib.CalibratedModelHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.CalibratedModelHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.CalibratedModelHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.CalibratedModelHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.CalibratedModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_CalibratedModelHandle

    def params(self):
        return _QuantLib.CalibratedModelHandle_params(self)

    def calibrate(self, *args):
        return _QuantLib.CalibratedModelHandle_calibrate(self, *args)

    def setParams(self, params):
        return _QuantLib.CalibratedModelHandle_setParams(self, params)

    def value(self, params, arg3):
        return _QuantLib.CalibratedModelHandle_value(self, params, arg3)

    def constraint(self):
        return _QuantLib.CalibratedModelHandle_constraint(self)

    def endCriteria(self):
        return _QuantLib.CalibratedModelHandle_endCriteria(self)

    def problemValues(self):
        return _QuantLib.CalibratedModelHandle_problemValues(self)

    def functionEvaluation(self):
        return _QuantLib.CalibratedModelHandle_functionEvaluation(self)

# Register CalibratedModelHandle in _QuantLib:
_QuantLib.CalibratedModelHandle_swigregister(CalibratedModelHandle)

class RelinkableCalibratedModelHandle(CalibratedModelHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableCalibratedModelHandle_swiginit(self, _QuantLib.new_RelinkableCalibratedModelHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableCalibratedModelHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableCalibratedModelHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableCalibratedModelHandle

# Register RelinkableCalibratedModelHandle in _QuantLib:
_QuantLib.RelinkableCalibratedModelHandle_swigregister(RelinkableCalibratedModelHandle)

class TimeGrid(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.TimeGrid_swiginit(self, _QuantLib.new_TimeGrid(*args))

    def __len__(self):
        return _QuantLib.TimeGrid___len__(self)

    def __getitem__(self, i):
        return _QuantLib.TimeGrid___getitem__(self, i)

    def dt(self, i):
        return _QuantLib.TimeGrid_dt(self, i)
    __swig_destroy__ = _QuantLib.delete_TimeGrid

# Register TimeGrid in _QuantLib:
_QuantLib.TimeGrid_swigregister(TimeGrid)

class Parameter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Parameter_swiginit(self, _QuantLib.new_Parameter())

    def params(self):
        return _QuantLib.Parameter_params(self)

    def setParam(self, i, x):
        return _QuantLib.Parameter_setParam(self, i, x)

    def testParams(self, params):
        return _QuantLib.Parameter_testParams(self, params)

    def size(self):
        return _QuantLib.Parameter_size(self)

    def __call__(self, t):
        return _QuantLib.Parameter___call__(self, t)

    def constraint(self):
        return _QuantLib.Parameter_constraint(self)
    __swig_destroy__ = _QuantLib.delete_Parameter

# Register Parameter in _QuantLib:
_QuantLib.Parameter_swigregister(Parameter)

class ConstantParameter(Parameter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ConstantParameter_swiginit(self, _QuantLib.new_ConstantParameter(*args))
    __swig_destroy__ = _QuantLib.delete_ConstantParameter

# Register ConstantParameter in _QuantLib:
_QuantLib.ConstantParameter_swigregister(ConstantParameter)

class NullParameter(Parameter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.NullParameter_swiginit(self, _QuantLib.new_NullParameter())
    __swig_destroy__ = _QuantLib.delete_NullParameter

# Register NullParameter in _QuantLib:
_QuantLib.NullParameter_swigregister(NullParameter)

class PiecewiseConstantParameter(Parameter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseConstantParameter_swiginit(self, _QuantLib.new_PiecewiseConstantParameter(*args))
    __swig_destroy__ = _QuantLib.delete_PiecewiseConstantParameter

# Register PiecewiseConstantParameter in _QuantLib:
_QuantLib.PiecewiseConstantParameter_swigregister(PiecewiseConstantParameter)

class Payoff(object):
    thisown = 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 __call__(self, price):
        return _QuantLib.Payoff___call__(self, price)
    __swig_destroy__ = _QuantLib.delete_Payoff

# Register Payoff in _QuantLib:
_QuantLib.Payoff_swigregister(Payoff)

class Option(Instrument):
    thisown = 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

    def payoff(self):
        return _QuantLib.Option_payoff(self)

    def exercise(self):
        return _QuantLib.Option_exercise(self)
    __swig_destroy__ = _QuantLib.delete_Option

# Register Option in _QuantLib:
_QuantLib.Option_swigregister(Option)

class Barrier(object):
    thisown = 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):
        _QuantLib.Barrier_swiginit(self, _QuantLib.new_Barrier())
    __swig_destroy__ = _QuantLib.delete_Barrier

# Register Barrier in _QuantLib:
_QuantLib.Barrier_swigregister(Barrier)

class DoubleBarrier(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    KnockIn = _QuantLib.DoubleBarrier_KnockIn
    KnockOut = _QuantLib.DoubleBarrier_KnockOut
    KIKO = _QuantLib.DoubleBarrier_KIKO
    KOKI = _QuantLib.DoubleBarrier_KOKI

    def __init__(self):
        _QuantLib.DoubleBarrier_swiginit(self, _QuantLib.new_DoubleBarrier())
    __swig_destroy__ = _QuantLib.delete_DoubleBarrier

# Register DoubleBarrier in _QuantLib:
_QuantLib.DoubleBarrier_swigregister(DoubleBarrier)

class TypePayoff(Payoff):
    thisown = 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 optionType(self):
        return _QuantLib.TypePayoff_optionType(self)
    __swig_destroy__ = _QuantLib.delete_TypePayoff

# Register TypePayoff in _QuantLib:
_QuantLib.TypePayoff_swigregister(TypePayoff)

class StrikedTypePayoff(TypePayoff):
    thisown = 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 strike(self):
        return _QuantLib.StrikedTypePayoff_strike(self)
    __swig_destroy__ = _QuantLib.delete_StrikedTypePayoff

# Register StrikedTypePayoff in _QuantLib:
_QuantLib.StrikedTypePayoff_swigregister(StrikedTypePayoff)

class OneAssetOption(Option):
    thisown = 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 delta(self):
        return _QuantLib.OneAssetOption_delta(self)

    def deltaForward(self):
        return _QuantLib.OneAssetOption_deltaForward(self)

    def elasticity(self):
        return _QuantLib.OneAssetOption_elasticity(self)

    def gamma(self):
        return _QuantLib.OneAssetOption_gamma(self)

    def theta(self):
        return _QuantLib.OneAssetOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.OneAssetOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.OneAssetOption_vega(self)

    def rho(self):
        return _QuantLib.OneAssetOption_rho(self)

    def dividendRho(self):
        return _QuantLib.OneAssetOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.OneAssetOption_strikeSensitivity(self)

    def itmCashProbability(self):
        return _QuantLib.OneAssetOption_itmCashProbability(self)
    __swig_destroy__ = _QuantLib.delete_OneAssetOption

# Register OneAssetOption in _QuantLib:
_QuantLib.OneAssetOption_swigregister(OneAssetOption)

class VanillaOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        _QuantLib.VanillaOption_swiginit(self, _QuantLib.new_VanillaOption(payoff, exercise))

    def impliedVolatility(self, targetValue, process, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-4, maxVol=4.0):
        return _QuantLib.VanillaOption_impliedVolatility(self, targetValue, process, accuracy, maxEvaluations, minVol, maxVol)

    def priceCurve(self):
        return _QuantLib.VanillaOption_priceCurve(self)
    __swig_destroy__ = _QuantLib.delete_VanillaOption

# Register VanillaOption in _QuantLib:
_QuantLib.VanillaOption_swigregister(VanillaOption)

class CalibrationPair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CalibrationPair_swiginit(self, _QuantLib.new_CalibrationPair(*args))
    first = property(_QuantLib.CalibrationPair_first_get, _QuantLib.CalibrationPair_first_set)
    second = property(_QuantLib.CalibrationPair_second_get, _QuantLib.CalibrationPair_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_CalibrationPair

# Register CalibrationPair in _QuantLib:
_QuantLib.CalibrationPair_swigregister(CalibrationPair)

class CalibrationSet(object):
    thisown = 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.CalibrationSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.CalibrationSet___nonzero__(self)

    def __bool__(self):
        return _QuantLib.CalibrationSet___bool__(self)

    def __len__(self):
        return _QuantLib.CalibrationSet___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.CalibrationSet___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.CalibrationSet___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.CalibrationSet___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.CalibrationSet___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.CalibrationSet___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.CalibrationSet___setitem__(self, *args)

    def pop(self):
        return _QuantLib.CalibrationSet_pop(self)

    def append(self, x):
        return _QuantLib.CalibrationSet_append(self, x)

    def empty(self):
        return _QuantLib.CalibrationSet_empty(self)

    def size(self):
        return _QuantLib.CalibrationSet_size(self)

    def swap(self, v):
        return _QuantLib.CalibrationSet_swap(self, v)

    def begin(self):
        return _QuantLib.CalibrationSet_begin(self)

    def end(self):
        return _QuantLib.CalibrationSet_end(self)

    def rbegin(self):
        return _QuantLib.CalibrationSet_rbegin(self)

    def rend(self):
        return _QuantLib.CalibrationSet_rend(self)

    def clear(self):
        return _QuantLib.CalibrationSet_clear(self)

    def get_allocator(self):
        return _QuantLib.CalibrationSet_get_allocator(self)

    def pop_back(self):
        return _QuantLib.CalibrationSet_pop_back(self)

    def erase(self, *args):
        return _QuantLib.CalibrationSet_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.CalibrationSet_swiginit(self, _QuantLib.new_CalibrationSet(*args))

    def push_back(self, x):
        return _QuantLib.CalibrationSet_push_back(self, x)

    def front(self):
        return _QuantLib.CalibrationSet_front(self)

    def back(self):
        return _QuantLib.CalibrationSet_back(self)

    def assign(self, n, x):
        return _QuantLib.CalibrationSet_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.CalibrationSet_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.CalibrationSet_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.CalibrationSet_reserve(self, n)

    def capacity(self):
        return _QuantLib.CalibrationSet_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CalibrationSet

# Register CalibrationSet in _QuantLib:
_QuantLib.CalibrationSet_swigregister(CalibrationSet)

class EuropeanOption(VanillaOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        _QuantLib.EuropeanOption_swiginit(self, _QuantLib.new_EuropeanOption(payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_EuropeanOption

# Register EuropeanOption in _QuantLib:
_QuantLib.EuropeanOption_swigregister(EuropeanOption)

class ForwardVanillaOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, moneyness, resetDate, payoff, exercise):
        _QuantLib.ForwardVanillaOption_swiginit(self, _QuantLib.new_ForwardVanillaOption(moneyness, resetDate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ForwardVanillaOption

# Register ForwardVanillaOption in _QuantLib:
_QuantLib.ForwardVanillaOption_swigregister(ForwardVanillaOption)

class QuantoVanillaOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        _QuantLib.QuantoVanillaOption_swiginit(self, _QuantLib.new_QuantoVanillaOption(payoff, exercise))

    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

# Register QuantoVanillaOption in _QuantLib:
_QuantLib.QuantoVanillaOption_swigregister(QuantoVanillaOption)

class QuantoForwardVanillaOption(ForwardVanillaOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, moneyness, resetDate, payoff, exercise):
        _QuantLib.QuantoForwardVanillaOption_swiginit(self, _QuantLib.new_QuantoForwardVanillaOption(moneyness, resetDate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_QuantoForwardVanillaOption

# Register QuantoForwardVanillaOption in _QuantLib:
_QuantLib.QuantoForwardVanillaOption_swigregister(QuantoForwardVanillaOption)

class MultiAssetOption(Option):
    thisown = 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 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)
    __swig_destroy__ = _QuantLib.delete_MultiAssetOption

# Register MultiAssetOption in _QuantLib:
_QuantLib.MultiAssetOption_swigregister(MultiAssetOption)

class AnalyticEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _QuantLib.AnalyticEuropeanEngine_swiginit(self, _QuantLib.new_AnalyticEuropeanEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_AnalyticEuropeanEngine

# Register AnalyticEuropeanEngine in _QuantLib:
_QuantLib.AnalyticEuropeanEngine_swigregister(AnalyticEuropeanEngine)

class HestonModel(CalibratedModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.HestonModel_swiginit(self, _QuantLib.new_HestonModel(process))

    def theta(self):
        return _QuantLib.HestonModel_theta(self)

    def kappa(self):
        return _QuantLib.HestonModel_kappa(self)

    def sigma(self):
        return _QuantLib.HestonModel_sigma(self)

    def rho(self):
        return _QuantLib.HestonModel_rho(self)

    def v0(self):
        return _QuantLib.HestonModel_v0(self)
    __swig_destroy__ = _QuantLib.delete_HestonModel

# Register HestonModel in _QuantLib:
_QuantLib.HestonModel_swigregister(HestonModel)

class HestonModelHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HestonModelHandle_swiginit(self, _QuantLib.new_HestonModelHandle(*args))

    def __deref__(self):
        return _QuantLib.HestonModelHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.HestonModelHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.HestonModelHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.HestonModelHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.HestonModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_HestonModelHandle

    def theta(self):
        return _QuantLib.HestonModelHandle_theta(self)

    def kappa(self):
        return _QuantLib.HestonModelHandle_kappa(self)

    def sigma(self):
        return _QuantLib.HestonModelHandle_sigma(self)

    def rho(self):
        return _QuantLib.HestonModelHandle_rho(self)

    def v0(self):
        return _QuantLib.HestonModelHandle_v0(self)

    def params(self):
        return _QuantLib.HestonModelHandle_params(self)

    def calibrate(self, *args):
        return _QuantLib.HestonModelHandle_calibrate(self, *args)

    def setParams(self, params):
        return _QuantLib.HestonModelHandle_setParams(self, params)

    def value(self, params, arg3):
        return _QuantLib.HestonModelHandle_value(self, params, arg3)

    def constraint(self):
        return _QuantLib.HestonModelHandle_constraint(self)

    def endCriteria(self):
        return _QuantLib.HestonModelHandle_endCriteria(self)

    def problemValues(self):
        return _QuantLib.HestonModelHandle_problemValues(self)

    def functionEvaluation(self):
        return _QuantLib.HestonModelHandle_functionEvaluation(self)

# Register HestonModelHandle in _QuantLib:
_QuantLib.HestonModelHandle_swigregister(HestonModelHandle)

class PiecewiseTimeDependentHestonModel(CalibratedModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, riskFreeRate, dividendYield, s0, v0, theta, kappa, sigma, rho, timeGrid):
        _QuantLib.PiecewiseTimeDependentHestonModel_swiginit(self, _QuantLib.new_PiecewiseTimeDependentHestonModel(riskFreeRate, dividendYield, s0, v0, theta, kappa, sigma, rho, timeGrid))

    def theta(self, t):
        return _QuantLib.PiecewiseTimeDependentHestonModel_theta(self, t)

    def kappa(self, t):
        return _QuantLib.PiecewiseTimeDependentHestonModel_kappa(self, t)

    def sigma(self, t):
        return _QuantLib.PiecewiseTimeDependentHestonModel_sigma(self, t)

    def rho(self, t):
        return _QuantLib.PiecewiseTimeDependentHestonModel_rho(self, t)

    def v0(self):
        return _QuantLib.PiecewiseTimeDependentHestonModel_v0(self)

    def s0(self):
        return _QuantLib.PiecewiseTimeDependentHestonModel_s0(self)

    def timeGrid(self):
        return _QuantLib.PiecewiseTimeDependentHestonModel_timeGrid(self)

    def dividendYield(self):
        return _QuantLib.PiecewiseTimeDependentHestonModel_dividendYield(self)

    def riskFreeRate(self):
        return _QuantLib.PiecewiseTimeDependentHestonModel_riskFreeRate(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseTimeDependentHestonModel

# Register PiecewiseTimeDependentHestonModel in _QuantLib:
_QuantLib.PiecewiseTimeDependentHestonModel_swigregister(PiecewiseTimeDependentHestonModel)

class AnalyticHestonEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Gatheral = _QuantLib.AnalyticHestonEngine_Gatheral
    BranchCorrection = _QuantLib.AnalyticHestonEngine_BranchCorrection
    AndersenPiterbarg = _QuantLib.AnalyticHestonEngine_AndersenPiterbarg
    AndersenPiterbargOptCV = _QuantLib.AnalyticHestonEngine_AndersenPiterbargOptCV
    AsymptoticChF = _QuantLib.AnalyticHestonEngine_AsymptoticChF
    OptimalCV = _QuantLib.AnalyticHestonEngine_OptimalCV

    def __init__(self, *args):
        _QuantLib.AnalyticHestonEngine_swiginit(self, _QuantLib.new_AnalyticHestonEngine(*args))

    def chF(self, real, imag, t):
        return _QuantLib.AnalyticHestonEngine_chF(self, real, imag, t)
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonEngine

# Register AnalyticHestonEngine in _QuantLib:
_QuantLib.AnalyticHestonEngine_swigregister(AnalyticHestonEngine)

class AnalyticHestonEngine_Integration(object):
    thisown = 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

    @staticmethod
    def gaussLaguerre(integrationOrder=128):
        return _QuantLib.AnalyticHestonEngine_Integration_gaussLaguerre(integrationOrder)

    @staticmethod
    def gaussLegendre(integrationOrder=128):
        return _QuantLib.AnalyticHestonEngine_Integration_gaussLegendre(integrationOrder)

    @staticmethod
    def gaussChebyshev(integrationOrder=128):
        return _QuantLib.AnalyticHestonEngine_Integration_gaussChebyshev(integrationOrder)

    @staticmethod
    def gaussChebyshev2nd(integrationOrder=128):
        return _QuantLib.AnalyticHestonEngine_Integration_gaussChebyshev2nd(integrationOrder)

    @staticmethod
    def gaussLobatto(relTolerance, absTolerance, maxEvaluations=1000):
        return _QuantLib.AnalyticHestonEngine_Integration_gaussLobatto(relTolerance, absTolerance, maxEvaluations)

    @staticmethod
    def gaussKronrod(absTolerance, maxEvaluations=1000):
        return _QuantLib.AnalyticHestonEngine_Integration_gaussKronrod(absTolerance, maxEvaluations)

    @staticmethod
    def simpson(absTolerance, maxEvaluations=1000):
        return _QuantLib.AnalyticHestonEngine_Integration_simpson(absTolerance, maxEvaluations)

    @staticmethod
    def trapezoid(absTolerance, maxEvaluations=1000):
        return _QuantLib.AnalyticHestonEngine_Integration_trapezoid(absTolerance, maxEvaluations)

    @staticmethod
    def discreteSimpson(evaluation=1000):
        return _QuantLib.AnalyticHestonEngine_Integration_discreteSimpson(evaluation)

    @staticmethod
    def discreteTrapezoid(evaluation=1000):
        return _QuantLib.AnalyticHestonEngine_Integration_discreteTrapezoid(evaluation)

    @staticmethod
    def andersenPiterbargIntegrationLimit(c_inf, epsilon, v0, t):
        return _QuantLib.AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(c_inf, epsilon, v0, t)

    def calculate(self, *args):
        return _QuantLib.AnalyticHestonEngine_Integration_calculate(self, *args)

    def numberOfEvaluations(self):
        return _QuantLib.AnalyticHestonEngine_Integration_numberOfEvaluations(self)

    def isAdaptiveIntegration(self):
        return _QuantLib.AnalyticHestonEngine_Integration_isAdaptiveIntegration(self)
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonEngine_Integration

# Register AnalyticHestonEngine_Integration in _QuantLib:
_QuantLib.AnalyticHestonEngine_Integration_swigregister(AnalyticHestonEngine_Integration)

def AnalyticHestonEngine_Integration_gaussLaguerre(integrationOrder=128):
    return _QuantLib.AnalyticHestonEngine_Integration_gaussLaguerre(integrationOrder)

def AnalyticHestonEngine_Integration_gaussLegendre(integrationOrder=128):
    return _QuantLib.AnalyticHestonEngine_Integration_gaussLegendre(integrationOrder)

def AnalyticHestonEngine_Integration_gaussChebyshev(integrationOrder=128):
    return _QuantLib.AnalyticHestonEngine_Integration_gaussChebyshev(integrationOrder)

def AnalyticHestonEngine_Integration_gaussChebyshev2nd(integrationOrder=128):
    return _QuantLib.AnalyticHestonEngine_Integration_gaussChebyshev2nd(integrationOrder)

def AnalyticHestonEngine_Integration_gaussLobatto(relTolerance, absTolerance, maxEvaluations=1000):
    return _QuantLib.AnalyticHestonEngine_Integration_gaussLobatto(relTolerance, absTolerance, maxEvaluations)

def AnalyticHestonEngine_Integration_gaussKronrod(absTolerance, maxEvaluations=1000):
    return _QuantLib.AnalyticHestonEngine_Integration_gaussKronrod(absTolerance, maxEvaluations)

def AnalyticHestonEngine_Integration_simpson(absTolerance, maxEvaluations=1000):
    return _QuantLib.AnalyticHestonEngine_Integration_simpson(absTolerance, maxEvaluations)

def AnalyticHestonEngine_Integration_trapezoid(absTolerance, maxEvaluations=1000):
    return _QuantLib.AnalyticHestonEngine_Integration_trapezoid(absTolerance, maxEvaluations)

def AnalyticHestonEngine_Integration_discreteSimpson(evaluation=1000):
    return _QuantLib.AnalyticHestonEngine_Integration_discreteSimpson(evaluation)

def AnalyticHestonEngine_Integration_discreteTrapezoid(evaluation=1000):
    return _QuantLib.AnalyticHestonEngine_Integration_discreteTrapezoid(evaluation)

def AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(c_inf, epsilon, v0, t):
    return _QuantLib.AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(c_inf, epsilon, v0, t)

class COSHestonEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, model, L=16, N=200):
        _QuantLib.COSHestonEngine_swiginit(self, _QuantLib.new_COSHestonEngine(model, L, N))
    __swig_destroy__ = _QuantLib.delete_COSHestonEngine

# Register COSHestonEngine in _QuantLib:
_QuantLib.COSHestonEngine_swigregister(COSHestonEngine)

class ExponentialFittingHestonEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AndersenPiterbarg = _QuantLib.ExponentialFittingHestonEngine_AndersenPiterbarg
    AndersenPiterbargOptCV = _QuantLib.ExponentialFittingHestonEngine_AndersenPiterbargOptCV
    AsymptoticChF = _QuantLib.ExponentialFittingHestonEngine_AsymptoticChF
    OptimalCV = _QuantLib.ExponentialFittingHestonEngine_OptimalCV

    def __init__(self, *args):
        _QuantLib.ExponentialFittingHestonEngine_swiginit(self, _QuantLib.new_ExponentialFittingHestonEngine(*args))
    __swig_destroy__ = _QuantLib.delete_ExponentialFittingHestonEngine

# Register ExponentialFittingHestonEngine in _QuantLib:
_QuantLib.ExponentialFittingHestonEngine_swigregister(ExponentialFittingHestonEngine)

class AnalyticPTDHestonEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Gatheral = _QuantLib.AnalyticPTDHestonEngine_Gatheral
    AndersenPiterbarg = _QuantLib.AnalyticPTDHestonEngine_AndersenPiterbarg

    def __init__(self, *args):
        _QuantLib.AnalyticPTDHestonEngine_swiginit(self, _QuantLib.new_AnalyticPTDHestonEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticPTDHestonEngine

# Register AnalyticPTDHestonEngine in _QuantLib:
_QuantLib.AnalyticPTDHestonEngine_swigregister(AnalyticPTDHestonEngine)

class BatesModel(HestonModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.BatesModel_swiginit(self, _QuantLib.new_BatesModel(process))

    def nu(self):
        return _QuantLib.BatesModel_nu(self)

    def delta(self):
        return _QuantLib.BatesModel_delta(self)

    def lambda_parameter(self):
        return _QuantLib.BatesModel_lambda_parameter(self)
    __swig_destroy__ = _QuantLib.delete_BatesModel

# Register BatesModel in _QuantLib:
_QuantLib.BatesModel_swigregister(BatesModel)

class BatesEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BatesEngine_swiginit(self, _QuantLib.new_BatesEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BatesEngine

# Register BatesEngine in _QuantLib:
_QuantLib.BatesEngine_swigregister(BatesEngine)

class IntegralEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _QuantLib.IntegralEngine_swiginit(self, _QuantLib.new_IntegralEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_IntegralEngine

# Register IntegralEngine in _QuantLib:
_QuantLib.IntegralEngine_swigregister(IntegralEngine)

class FDBermudanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):

        from warnings import warn
        warn("FDBermudanEngine is deprecated; use FdBlackScholesVanillaEngine")


        _QuantLib.FDBermudanEngine_swiginit(self, _QuantLib.new_FDBermudanEngine(process, timeSteps, gridPoints, timeDependent))
    __swig_destroy__ = _QuantLib.delete_FDBermudanEngine

# Register FDBermudanEngine in _QuantLib:
_QuantLib.FDBermudanEngine_swigregister(FDBermudanEngine)

class FDEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):

        from warnings import warn
        warn("FDEuropeanEngine is deprecated; use FdBlackScholesVanillaEngine")


        _QuantLib.FDEuropeanEngine_swiginit(self, _QuantLib.new_FDEuropeanEngine(process, timeSteps, gridPoints, timeDependent))
    __swig_destroy__ = _QuantLib.delete_FDEuropeanEngine

# Register FDEuropeanEngine in _QuantLib:
_QuantLib.FDEuropeanEngine_swigregister(FDEuropeanEngine)

class BinomialCRRVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialCRRVanillaEngine_swiginit(self, _QuantLib.new_BinomialCRRVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRVanillaEngine

# Register BinomialCRRVanillaEngine in _QuantLib:
_QuantLib.BinomialCRRVanillaEngine_swigregister(BinomialCRRVanillaEngine)

class BinomialJRVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialJRVanillaEngine_swiginit(self, _QuantLib.new_BinomialJRVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRVanillaEngine

# Register BinomialJRVanillaEngine in _QuantLib:
_QuantLib.BinomialJRVanillaEngine_swigregister(BinomialJRVanillaEngine)

class BinomialEQPVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialEQPVanillaEngine_swiginit(self, _QuantLib.new_BinomialEQPVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPVanillaEngine

# Register BinomialEQPVanillaEngine in _QuantLib:
_QuantLib.BinomialEQPVanillaEngine_swigregister(BinomialEQPVanillaEngine)

class BinomialTrigeorgisVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialTrigeorgisVanillaEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisVanillaEngine

# Register BinomialTrigeorgisVanillaEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisVanillaEngine_swigregister(BinomialTrigeorgisVanillaEngine)

class BinomialTianVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialTianVanillaEngine_swiginit(self, _QuantLib.new_BinomialTianVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianVanillaEngine

# Register BinomialTianVanillaEngine in _QuantLib:
_QuantLib.BinomialTianVanillaEngine_swigregister(BinomialTianVanillaEngine)

class BinomialLRVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialLRVanillaEngine_swiginit(self, _QuantLib.new_BinomialLRVanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRVanillaEngine

# Register BinomialLRVanillaEngine in _QuantLib:
_QuantLib.BinomialLRVanillaEngine_swigregister(BinomialLRVanillaEngine)

class BinomialJ4VanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialJ4VanillaEngine_swiginit(self, _QuantLib.new_BinomialJ4VanillaEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4VanillaEngine

# Register BinomialJ4VanillaEngine in _QuantLib:
_QuantLib.BinomialJ4VanillaEngine_swigregister(BinomialJ4VanillaEngine)


def BinomialVanillaEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRVanillaEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRVanillaEngine
    elif type == "eqp":
        cls = BinomialEQPVanillaEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisVanillaEngine
    elif type == "tian":
        cls = BinomialTianVanillaEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRVanillaEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4VanillaEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class LsmBasisSystem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Monomial = _QuantLib.LsmBasisSystem_Monomial
    Laguerre = _QuantLib.LsmBasisSystem_Laguerre
    Hermite = _QuantLib.LsmBasisSystem_Hermite
    Hyperbolic = _QuantLib.LsmBasisSystem_Hyperbolic
    Legendre = _QuantLib.LsmBasisSystem_Legendre
    Chebyshev = _QuantLib.LsmBasisSystem_Chebyshev
    Chebyshev2nd = _QuantLib.LsmBasisSystem_Chebyshev2nd

    def __init__(self):
        _QuantLib.LsmBasisSystem_swiginit(self, _QuantLib.new_LsmBasisSystem())
    __swig_destroy__ = _QuantLib.delete_LsmBasisSystem

# Register LsmBasisSystem in _QuantLib:
_QuantLib.LsmBasisSystem_swigregister(LsmBasisSystem)

class MCPREuropeanEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPREuropeanEngine_swiginit(self, _QuantLib.new_MCPREuropeanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanEngine

# Register MCPREuropeanEngine in _QuantLib:
_QuantLib.MCPREuropeanEngine_swigregister(MCPREuropeanEngine)

class MCLDEuropeanEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDEuropeanEngine_swiginit(self, _QuantLib.new_MCLDEuropeanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanEngine

# Register MCLDEuropeanEngine in _QuantLib:
_QuantLib.MCLDEuropeanEngine_swigregister(MCLDEuropeanEngine)


def MCEuropeanEngine(process,
                     traits,
                     timeSteps=None,
                     timeStepsPerYear=None,
                     brownianBridge=False,
                     antitheticVariate=False,
                     requiredSamples=None,
                     requiredTolerance=None,
                     maxSamples=None,
                     seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRAmericanEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRAmericanEngine_swiginit(self, _QuantLib.new_MCPRAmericanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRAmericanEngine

# Register MCPRAmericanEngine in _QuantLib:
_QuantLib.MCPRAmericanEngine_swigregister(MCPRAmericanEngine)

class MCLDAmericanEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDAmericanEngine_swiginit(self, _QuantLib.new_MCLDAmericanEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDAmericanEngine

# Register MCLDAmericanEngine in _QuantLib:
_QuantLib.MCLDAmericanEngine_swigregister(MCLDAmericanEngine)


def MCAmericanEngine(process,
                     traits,
                     timeSteps=None,
                     timeStepsPerYear=None,
                     antitheticVariate=False,
                     controlVariate=False,
                     requiredSamples=None,
                     requiredTolerance=None,
                     maxSamples=None,
                     seed=0,
                     polynomOrder=2,
                     polynomType=LsmBasisSystem.Monomial,
                     nCalibrationSamples=2048,
                     antitheticVariateCalibration=None,
                     seedCalibration=None):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRAmericanEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDAmericanEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               controlVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               polynomOrder,
               polynomType,
               nCalibrationSamples,
               antitheticVariateCalibration,
               seedCalibration if seedCalibration is not None else nullInt())

class MCPREuropeanHestonEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPREuropeanHestonEngine_swiginit(self, _QuantLib.new_MCPREuropeanHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanHestonEngine

# Register MCPREuropeanHestonEngine in _QuantLib:
_QuantLib.MCPREuropeanHestonEngine_swigregister(MCPREuropeanHestonEngine)

class MCLDEuropeanHestonEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDEuropeanHestonEngine_swiginit(self, _QuantLib.new_MCLDEuropeanHestonEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanHestonEngine

# Register MCLDEuropeanHestonEngine in _QuantLib:
_QuantLib.MCLDEuropeanHestonEngine_swigregister(MCLDEuropeanHestonEngine)


def MCEuropeanHestonEngine(process,
                           traits,
                           timeSteps=None,
                           timeStepsPerYear=None,
                           antitheticVariate=False,
                           requiredSamples=None,
                           requiredTolerance=None,
                           maxSamples=None,
                           seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanHestonEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanHestonEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class FDAmericanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):

        from warnings import warn
        warn("FDAmericanEngine is deprecated; use FdBlackScholesVanillaEngine")


        _QuantLib.FDAmericanEngine_swiginit(self, _QuantLib.new_FDAmericanEngine(process, timeSteps, gridPoints, timeDependent))
    __swig_destroy__ = _QuantLib.delete_FDAmericanEngine

# Register FDAmericanEngine in _QuantLib:
_QuantLib.FDAmericanEngine_swigregister(FDAmericanEngine)

class FDShoutEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        _QuantLib.FDShoutEngine_swiginit(self, _QuantLib.new_FDShoutEngine(process, timeSteps, gridPoints, timeDependent))
    __swig_destroy__ = _QuantLib.delete_FDShoutEngine

# Register FDShoutEngine in _QuantLib:
_QuantLib.FDShoutEngine_swigregister(FDShoutEngine)

class ContinuousArithmeticAsianLevyEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, runningAverage, startDate):
        _QuantLib.ContinuousArithmeticAsianLevyEngine_swiginit(self, _QuantLib.new_ContinuousArithmeticAsianLevyEngine(process, runningAverage, startDate))
    __swig_destroy__ = _QuantLib.delete_ContinuousArithmeticAsianLevyEngine

# Register ContinuousArithmeticAsianLevyEngine in _QuantLib:
_QuantLib.ContinuousArithmeticAsianLevyEngine_swigregister(ContinuousArithmeticAsianLevyEngine)

class FdBlackScholesAsianEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, tGrid, xGrid, aGrid):
        _QuantLib.FdBlackScholesAsianEngine_swiginit(self, _QuantLib.new_FdBlackScholesAsianEngine(process, tGrid, xGrid, aGrid))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesAsianEngine

# Register FdBlackScholesAsianEngine in _QuantLib:
_QuantLib.FdBlackScholesAsianEngine_swigregister(FdBlackScholesAsianEngine)

class BaroneAdesiWhaleyApproximationEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.BaroneAdesiWhaleyApproximationEngine_swiginit(self, _QuantLib.new_BaroneAdesiWhaleyApproximationEngine(process))
    __swig_destroy__ = _QuantLib.delete_BaroneAdesiWhaleyApproximationEngine

# Register BaroneAdesiWhaleyApproximationEngine in _QuantLib:
_QuantLib.BaroneAdesiWhaleyApproximationEngine_swigregister(BaroneAdesiWhaleyApproximationEngine)


def BaroneAdesiWhaleyEngine(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (BaroneAdesiWhaleyEngine.__name__, BaroneAdesiWhaleyApproximationEngine.__name__))
    return BaroneAdesiWhaleyApproximationEngine(*args, **kwargs)

class BjerksundStenslandApproximationEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.BjerksundStenslandApproximationEngine_swiginit(self, _QuantLib.new_BjerksundStenslandApproximationEngine(process))
    __swig_destroy__ = _QuantLib.delete_BjerksundStenslandApproximationEngine

# Register BjerksundStenslandApproximationEngine in _QuantLib:
_QuantLib.BjerksundStenslandApproximationEngine_swigregister(BjerksundStenslandApproximationEngine)


def BjerksundStenslandEngine(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (BjerksundStenslandEngine.__name__, BjerksundStenslandApproximationEngine.__name__))
    return BjerksundStenslandApproximationEngine(*args, **kwargs)

class JuQuadraticApproximationEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.JuQuadraticApproximationEngine_swiginit(self, _QuantLib.new_JuQuadraticApproximationEngine(process))
    __swig_destroy__ = _QuantLib.delete_JuQuadraticApproximationEngine

# Register JuQuadraticApproximationEngine in _QuantLib:
_QuantLib.JuQuadraticApproximationEngine_swigregister(JuQuadraticApproximationEngine)

class AnalyticDigitalAmericanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticDigitalAmericanEngine_swiginit(self, _QuantLib.new_AnalyticDigitalAmericanEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanEngine

# Register AnalyticDigitalAmericanEngine in _QuantLib:
_QuantLib.AnalyticDigitalAmericanEngine_swigregister(AnalyticDigitalAmericanEngine)

class AnalyticDigitalAmericanKOEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticDigitalAmericanKOEngine_swiginit(self, _QuantLib.new_AnalyticDigitalAmericanKOEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanKOEngine

# Register AnalyticDigitalAmericanKOEngine in _QuantLib:
_QuantLib.AnalyticDigitalAmericanKOEngine_swigregister(AnalyticDigitalAmericanKOEngine)

class DividendVanillaOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise, dividendDates, dividends):
        _QuantLib.DividendVanillaOption_swiginit(self, _QuantLib.new_DividendVanillaOption(payoff, exercise, dividendDates, dividends))

    def impliedVolatility(self, targetValue, process, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-4, maxVol=4.0):
        return _QuantLib.DividendVanillaOption_impliedVolatility(self, targetValue, process, accuracy, maxEvaluations, minVol, maxVol)
    __swig_destroy__ = _QuantLib.delete_DividendVanillaOption

# Register DividendVanillaOption in _QuantLib:
_QuantLib.DividendVanillaOption_swigregister(DividendVanillaOption)

class AnalyticDividendEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticDividendEuropeanEngine_swiginit(self, _QuantLib.new_AnalyticDividendEuropeanEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDividendEuropeanEngine

# Register AnalyticDividendEuropeanEngine in _QuantLib:
_QuantLib.AnalyticDividendEuropeanEngine_swigregister(AnalyticDividendEuropeanEngine)

class FDDividendEuropeanEngine(PricingEngine):
    thisown = 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_FDDividendEuropeanEngine

# Register FDDividendEuropeanEngine in _QuantLib:
_QuantLib.FDDividendEuropeanEngine_swigregister(FDDividendEuropeanEngine)

def FDDividendEuropeanEngineT(process, timeSteps=100, gridPoints=100, timeDependent=False):

    from warnings import warn
    warn("FDDividendEuropeanEngine is deprecated; use FdBlackScholesVanillaEngine")


    val = _QuantLib.new_FDDividendEuropeanEngineT(process, timeSteps, gridPoints, timeDependent)
    return val

class FDDividendAmericanEngine(PricingEngine):
    thisown = 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_FDDividendAmericanEngine

# Register FDDividendAmericanEngine in _QuantLib:
_QuantLib.FDDividendAmericanEngine_swigregister(FDDividendAmericanEngine)

def FDDividendAmericanEngineT(process, timeSteps=100, gridPoints=100, timeDependent=False):

    from warnings import warn
    warn("FDDividendAmericanEngine is deprecated; use FdBlackScholesVanillaEngine")


    val = _QuantLib.new_FDDividendAmericanEngineT(process, timeSteps, gridPoints, timeDependent)
    return val

class BarrierOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, barrierType, barrier, rebate, payoff, exercise):
        _QuantLib.BarrierOption_swiginit(self, _QuantLib.new_BarrierOption(barrierType, barrier, rebate, payoff, exercise))

    def impliedVolatility(self, targetValue, process, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-4, maxVol=4.0):
        return _QuantLib.BarrierOption_impliedVolatility(self, targetValue, process, accuracy, maxEvaluations, minVol, maxVol)
    __swig_destroy__ = _QuantLib.delete_BarrierOption

# Register BarrierOption in _QuantLib:
_QuantLib.BarrierOption_swigregister(BarrierOption)

class DividendBarrierOption(BarrierOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, barrierType, barrier, rebate, payoff, exercise, dividendDates, dividends):
        _QuantLib.DividendBarrierOption_swiginit(self, _QuantLib.new_DividendBarrierOption(barrierType, barrier, rebate, payoff, exercise, dividendDates, dividends))
    __swig_destroy__ = _QuantLib.delete_DividendBarrierOption

# Register DividendBarrierOption in _QuantLib:
_QuantLib.DividendBarrierOption_swigregister(DividendBarrierOption)

class AnalyticBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _QuantLib.AnalyticBarrierEngine_swiginit(self, _QuantLib.new_AnalyticBarrierEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_AnalyticBarrierEngine

# Register AnalyticBarrierEngine in _QuantLib:
_QuantLib.AnalyticBarrierEngine_swigregister(AnalyticBarrierEngine)

class MCPRBarrierEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRBarrierEngine_swiginit(self, _QuantLib.new_MCPRBarrierEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRBarrierEngine

# Register MCPRBarrierEngine in _QuantLib:
_QuantLib.MCPRBarrierEngine_swigregister(MCPRBarrierEngine)

class MCLDBarrierEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDBarrierEngine_swiginit(self, _QuantLib.new_MCLDBarrierEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDBarrierEngine

# Register MCLDBarrierEngine in _QuantLib:
_QuantLib.MCLDBarrierEngine_swigregister(MCLDBarrierEngine)


def MCBarrierEngine(process,
                    traits,
                    timeSteps=None,
                    timeStepsPerYear=None,
                    brownianBridge=False,
                    antitheticVariate=False,
                    requiredSamples=None,
                    requiredTolerance=None,
                    maxSamples=None,
                    isBiased=False,
                    seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRBarrierEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDBarrierEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               isBiased,
               seed)

class FdmSchemeDesc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HundsdorferType = _QuantLib.FdmSchemeDesc_HundsdorferType
    DouglasType = _QuantLib.FdmSchemeDesc_DouglasType
    CraigSneydType = _QuantLib.FdmSchemeDesc_CraigSneydType
    ModifiedCraigSneydType = _QuantLib.FdmSchemeDesc_ModifiedCraigSneydType
    ImplicitEulerType = _QuantLib.FdmSchemeDesc_ImplicitEulerType
    ExplicitEulerType = _QuantLib.FdmSchemeDesc_ExplicitEulerType
    MethodOfLinesType = _QuantLib.FdmSchemeDesc_MethodOfLinesType
    TrBDF2Type = _QuantLib.FdmSchemeDesc_TrBDF2Type
    CrankNicolsonType = _QuantLib.FdmSchemeDesc_CrankNicolsonType

    def __init__(self, type, theta, mu):
        _QuantLib.FdmSchemeDesc_swiginit(self, _QuantLib.new_FdmSchemeDesc(type, theta, mu))
    type = property(_QuantLib.FdmSchemeDesc_type_get)
    theta = property(_QuantLib.FdmSchemeDesc_theta_get)
    mu = property(_QuantLib.FdmSchemeDesc_mu_get)

    @staticmethod
    def Douglas():
        return _QuantLib.FdmSchemeDesc_Douglas()

    @staticmethod
    def CrankNicolson():
        return _QuantLib.FdmSchemeDesc_CrankNicolson()

    @staticmethod
    def ImplicitEuler():
        return _QuantLib.FdmSchemeDesc_ImplicitEuler()

    @staticmethod
    def ExplicitEuler():
        return _QuantLib.FdmSchemeDesc_ExplicitEuler()

    @staticmethod
    def CraigSneyd():
        return _QuantLib.FdmSchemeDesc_CraigSneyd()

    @staticmethod
    def ModifiedCraigSneyd():
        return _QuantLib.FdmSchemeDesc_ModifiedCraigSneyd()

    @staticmethod
    def Hundsdorfer():
        return _QuantLib.FdmSchemeDesc_Hundsdorfer()

    @staticmethod
    def ModifiedHundsdorfer():
        return _QuantLib.FdmSchemeDesc_ModifiedHundsdorfer()

    @staticmethod
    def MethodOfLines(eps=0.001, relInitStepSize=0.01):
        return _QuantLib.FdmSchemeDesc_MethodOfLines(eps, relInitStepSize)

    @staticmethod
    def TrBDF2():
        return _QuantLib.FdmSchemeDesc_TrBDF2()
    __swig_destroy__ = _QuantLib.delete_FdmSchemeDesc

# Register FdmSchemeDesc in _QuantLib:
_QuantLib.FdmSchemeDesc_swigregister(FdmSchemeDesc)

def FdmSchemeDesc_Douglas():
    return _QuantLib.FdmSchemeDesc_Douglas()

def FdmSchemeDesc_CrankNicolson():
    return _QuantLib.FdmSchemeDesc_CrankNicolson()

def FdmSchemeDesc_ImplicitEuler():
    return _QuantLib.FdmSchemeDesc_ImplicitEuler()

def FdmSchemeDesc_ExplicitEuler():
    return _QuantLib.FdmSchemeDesc_ExplicitEuler()

def FdmSchemeDesc_CraigSneyd():
    return _QuantLib.FdmSchemeDesc_CraigSneyd()

def FdmSchemeDesc_ModifiedCraigSneyd():
    return _QuantLib.FdmSchemeDesc_ModifiedCraigSneyd()

def FdmSchemeDesc_Hundsdorfer():
    return _QuantLib.FdmSchemeDesc_Hundsdorfer()

def FdmSchemeDesc_ModifiedHundsdorfer():
    return _QuantLib.FdmSchemeDesc_ModifiedHundsdorfer()

def FdmSchemeDesc_MethodOfLines(eps=0.001, relInitStepSize=0.01):
    return _QuantLib.FdmSchemeDesc_MethodOfLines(eps, relInitStepSize)

def FdmSchemeDesc_TrBDF2():
    return _QuantLib.FdmSchemeDesc_TrBDF2()

class FdmQuantoHelper(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rTS, fTS, fxVolTS, equityFxCorrelation, exchRateATMlevel):
        _QuantLib.FdmQuantoHelper_swiginit(self, _QuantLib.new_FdmQuantoHelper(rTS, fTS, fxVolTS, equityFxCorrelation, exchRateATMlevel))
    __swig_destroy__ = _QuantLib.delete_FdmQuantoHelper

# Register FdmQuantoHelper in _QuantLib:
_QuantLib.FdmQuantoHelper_swigregister(FdmQuantoHelper)

class FdBlackScholesVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Spot = _QuantLib.FdBlackScholesVanillaEngine_Spot
    Escrowed = _QuantLib.FdBlackScholesVanillaEngine_Escrowed

    def __init__(self, *args):
        _QuantLib.FdBlackScholesVanillaEngine_swiginit(self, _QuantLib.new_FdBlackScholesVanillaEngine(*args))

    @staticmethod
    def make(*args, **kwargs):
        return _QuantLib.FdBlackScholesVanillaEngine_make(*args, **kwargs)
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesVanillaEngine

# Register FdBlackScholesVanillaEngine in _QuantLib:
_QuantLib.FdBlackScholesVanillaEngine_swigregister(FdBlackScholesVanillaEngine)

def FdBlackScholesVanillaEngine_make(*args, **kwargs):
    return _QuantLib.FdBlackScholesVanillaEngine_make(*args, **kwargs)

class FdOrnsteinUhlenbeckVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdOrnsteinUhlenbeckVanillaEngine_swiginit(self, _QuantLib.new_FdOrnsteinUhlenbeckVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdOrnsteinUhlenbeckVanillaEngine

# Register FdOrnsteinUhlenbeckVanillaEngine in _QuantLib:
_QuantLib.FdOrnsteinUhlenbeckVanillaEngine_swigregister(FdOrnsteinUhlenbeckVanillaEngine)

class FdBatesVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdBatesVanillaEngine_swiginit(self, _QuantLib.new_FdBatesVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBatesVanillaEngine

# Register FdBatesVanillaEngine in _QuantLib:
_QuantLib.FdBatesVanillaEngine_swigregister(FdBatesVanillaEngine)

class FdHestonVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdHestonVanillaEngine_swiginit(self, _QuantLib.new_FdHestonVanillaEngine(*args))

    @staticmethod
    def make(*args, **kwargs):
        return _QuantLib.FdHestonVanillaEngine_make(*args, **kwargs)
    __swig_destroy__ = _QuantLib.delete_FdHestonVanillaEngine

# Register FdHestonVanillaEngine in _QuantLib:
_QuantLib.FdHestonVanillaEngine_swigregister(FdHestonVanillaEngine)

def FdHestonVanillaEngine_make(*args, **kwargs):
    return _QuantLib.FdHestonVanillaEngine_make(*args, **kwargs)

class AnalyticCEVEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, f0, alpha, beta, rTS):
        _QuantLib.AnalyticCEVEngine_swiginit(self, _QuantLib.new_AnalyticCEVEngine(f0, alpha, beta, rTS))
    __swig_destroy__ = _QuantLib.delete_AnalyticCEVEngine

# Register AnalyticCEVEngine in _QuantLib:
_QuantLib.AnalyticCEVEngine_swigregister(AnalyticCEVEngine)

class FdCEVVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdCEVVanillaEngine_swiginit(self, _QuantLib.new_FdCEVVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdCEVVanillaEngine

# Register FdCEVVanillaEngine in _QuantLib:
_QuantLib.FdCEVVanillaEngine_swigregister(FdCEVVanillaEngine)

class FdSabrVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdSabrVanillaEngine_swiginit(self, _QuantLib.new_FdSabrVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdSabrVanillaEngine

# Register FdSabrVanillaEngine in _QuantLib:
_QuantLib.FdSabrVanillaEngine_swigregister(FdSabrVanillaEngine)

class FdBlackScholesBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdBlackScholesBarrierEngine_swiginit(self, _QuantLib.new_FdBlackScholesBarrierEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesBarrierEngine

# Register FdBlackScholesBarrierEngine in _QuantLib:
_QuantLib.FdBlackScholesBarrierEngine_swigregister(FdBlackScholesBarrierEngine)

class FdBlackScholesRebateEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdBlackScholesRebateEngine_swiginit(self, _QuantLib.new_FdBlackScholesRebateEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesRebateEngine

# Register FdBlackScholesRebateEngine in _QuantLib:
_QuantLib.FdBlackScholesRebateEngine_swigregister(FdBlackScholesRebateEngine)

class FdHestonBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdHestonBarrierEngine_swiginit(self, _QuantLib.new_FdHestonBarrierEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHestonBarrierEngine

# Register FdHestonBarrierEngine in _QuantLib:
_QuantLib.FdHestonBarrierEngine_swigregister(FdHestonBarrierEngine)

class FdHestonRebateEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdHestonRebateEngine_swiginit(self, _QuantLib.new_FdHestonRebateEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHestonRebateEngine

# Register FdHestonRebateEngine in _QuantLib:
_QuantLib.FdHestonRebateEngine_swigregister(FdHestonRebateEngine)

class AnalyticBinaryBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticBinaryBarrierEngine_swiginit(self, _QuantLib.new_AnalyticBinaryBarrierEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticBinaryBarrierEngine

# Register AnalyticBinaryBarrierEngine in _QuantLib:
_QuantLib.AnalyticBinaryBarrierEngine_swigregister(AnalyticBinaryBarrierEngine)

class BinomialCRRBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialCRRBarrierEngine_swiginit(self, _QuantLib.new_BinomialCRRBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRBarrierEngine

# Register BinomialCRRBarrierEngine in _QuantLib:
_QuantLib.BinomialCRRBarrierEngine_swigregister(BinomialCRRBarrierEngine)

class BinomialJRBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialJRBarrierEngine_swiginit(self, _QuantLib.new_BinomialJRBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRBarrierEngine

# Register BinomialJRBarrierEngine in _QuantLib:
_QuantLib.BinomialJRBarrierEngine_swigregister(BinomialJRBarrierEngine)

class BinomialEQPBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialEQPBarrierEngine_swiginit(self, _QuantLib.new_BinomialEQPBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPBarrierEngine

# Register BinomialEQPBarrierEngine in _QuantLib:
_QuantLib.BinomialEQPBarrierEngine_swigregister(BinomialEQPBarrierEngine)

class BinomialTrigeorgisBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialTrigeorgisBarrierEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisBarrierEngine

# Register BinomialTrigeorgisBarrierEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisBarrierEngine_swigregister(BinomialTrigeorgisBarrierEngine)

class BinomialTianBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialTianBarrierEngine_swiginit(self, _QuantLib.new_BinomialTianBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianBarrierEngine

# Register BinomialTianBarrierEngine in _QuantLib:
_QuantLib.BinomialTianBarrierEngine_swigregister(BinomialTianBarrierEngine)

class BinomialLRBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialLRBarrierEngine_swiginit(self, _QuantLib.new_BinomialLRBarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRBarrierEngine

# Register BinomialLRBarrierEngine in _QuantLib:
_QuantLib.BinomialLRBarrierEngine_swigregister(BinomialLRBarrierEngine)

class BinomialJ4BarrierEngine(PricingEngine):
    r"""
    Binomial Engine for barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
    up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    Boyle-Lau adjustment is controlled by parameter max_steps.
    If max_steps is equal to steps Boyle-Lau is disabled.
    Il max_steps is 0 (default value), max_steps is calculated by capping it to
    5*steps when Boyle-Lau would need more than 1000 steps.
    If max_steps is specified, it would limit binomial steps to this value.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps, max_steps=0):
        r"""
        Binomial Engine for barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed
        up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        Boyle-Lau adjustment is controlled by parameter max_steps.
        If max_steps is equal to steps Boyle-Lau is disabled.
        Il max_steps is 0 (default value), max_steps is calculated by capping it to
        5*steps when Boyle-Lau would need more than 1000 steps.
        If max_steps is specified, it would limit binomial steps to this value.

        """
        _QuantLib.BinomialJ4BarrierEngine_swiginit(self, _QuantLib.new_BinomialJ4BarrierEngine(arg2, steps, max_steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4BarrierEngine

# Register BinomialJ4BarrierEngine in _QuantLib:
_QuantLib.BinomialJ4BarrierEngine_swigregister(BinomialJ4BarrierEngine)


def BinomialBarrierEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRBarrierEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRBarrierEngine
    elif type == "eqp":
        cls = BinomialEQPBarrierEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisBarrierEngine
    elif type == "tian":
        cls = BinomialTianBarrierEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRBarrierEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4BarrierEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class ForwardEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _QuantLib.ForwardEuropeanEngine_swiginit(self, _QuantLib.new_ForwardEuropeanEngine(arg2))
    __swig_destroy__ = _QuantLib.delete_ForwardEuropeanEngine

# Register ForwardEuropeanEngine in _QuantLib:
_QuantLib.ForwardEuropeanEngine_swigregister(ForwardEuropeanEngine)

class QuantoEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        _QuantLib.QuantoEuropeanEngine_swiginit(self, _QuantLib.new_QuantoEuropeanEngine(process, foreignRiskFreeRate, exchangeRateVolatility, correlation))
    __swig_destroy__ = _QuantLib.delete_QuantoEuropeanEngine

# Register QuantoEuropeanEngine in _QuantLib:
_QuantLib.QuantoEuropeanEngine_swigregister(QuantoEuropeanEngine)

class QuantoForwardEuropeanEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        _QuantLib.QuantoForwardEuropeanEngine_swiginit(self, _QuantLib.new_QuantoForwardEuropeanEngine(process, foreignRiskFreeRate, exchangeRateVolatility, correlation))
    __swig_destroy__ = _QuantLib.delete_QuantoForwardEuropeanEngine

# Register QuantoForwardEuropeanEngine in _QuantLib:
_QuantLib.QuantoForwardEuropeanEngine_swigregister(QuantoForwardEuropeanEngine)

class BlackCalculator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, forward, stdDev, discount=1.0):
        _QuantLib.BlackCalculator_swiginit(self, _QuantLib.new_BlackCalculator(payoff, forward, stdDev, discount))

    def value(self):
        return _QuantLib.BlackCalculator_value(self)

    def deltaForward(self):
        return _QuantLib.BlackCalculator_deltaForward(self)

    def delta(self, spot):
        return _QuantLib.BlackCalculator_delta(self, spot)

    def elasticityForward(self):
        return _QuantLib.BlackCalculator_elasticityForward(self)

    def elasticity(self, spot):
        return _QuantLib.BlackCalculator_elasticity(self, spot)

    def gammaForward(self):
        return _QuantLib.BlackCalculator_gammaForward(self)

    def gamma(self, spot):
        return _QuantLib.BlackCalculator_gamma(self, spot)

    def theta(self, spot, maturity):
        return _QuantLib.BlackCalculator_theta(self, spot, maturity)

    def thetaPerDay(self, spot, maturity):
        return _QuantLib.BlackCalculator_thetaPerDay(self, spot, maturity)

    def vega(self, maturity):
        return _QuantLib.BlackCalculator_vega(self, maturity)

    def rho(self, maturity):
        return _QuantLib.BlackCalculator_rho(self, maturity)

    def dividendRho(self, maturity):
        return _QuantLib.BlackCalculator_dividendRho(self, maturity)

    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

# Register BlackCalculator in _QuantLib:
_QuantLib.BlackCalculator_swigregister(BlackCalculator)

class Average(object):
    thisown = 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):
        _QuantLib.Average_swiginit(self, _QuantLib.new_Average())
    __swig_destroy__ = _QuantLib.delete_Average

# Register Average in _QuantLib:
_QuantLib.Average_swigregister(Average)

class ContinuousAveragingAsianOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, averageType, payoff, exercise):
        _QuantLib.ContinuousAveragingAsianOption_swiginit(self, _QuantLib.new_ContinuousAveragingAsianOption(averageType, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_ContinuousAveragingAsianOption

# Register ContinuousAveragingAsianOption in _QuantLib:
_QuantLib.ContinuousAveragingAsianOption_swigregister(ContinuousAveragingAsianOption)

class DiscreteAveragingAsianOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, averageType, runningAccumulator, pastFixings, fixingDates, payoff, exercise):
        _QuantLib.DiscreteAveragingAsianOption_swiginit(self, _QuantLib.new_DiscreteAveragingAsianOption(averageType, runningAccumulator, pastFixings, fixingDates, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_DiscreteAveragingAsianOption

# Register DiscreteAveragingAsianOption in _QuantLib:
_QuantLib.DiscreteAveragingAsianOption_swigregister(DiscreteAveragingAsianOption)

class AnalyticContinuousGeometricAveragePriceAsianEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit(self, _QuantLib.new_AnalyticContinuousGeometricAveragePriceAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousGeometricAveragePriceAsianEngine

# Register AnalyticContinuousGeometricAveragePriceAsianEngine in _QuantLib:
_QuantLib.AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister(AnalyticContinuousGeometricAveragePriceAsianEngine)

class AnalyticDiscreteGeometricAveragePriceAsianEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit(self, _QuantLib.new_AnalyticDiscreteGeometricAveragePriceAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAveragePriceAsianEngine

# Register AnalyticDiscreteGeometricAveragePriceAsianEngine in _QuantLib:
_QuantLib.AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister(AnalyticDiscreteGeometricAveragePriceAsianEngine)

class AnalyticDiscreteGeometricAverageStrikeAsianEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticDiscreteGeometricAverageStrikeAsianEngine_swiginit(self, _QuantLib.new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine

# Register AnalyticDiscreteGeometricAverageStrikeAsianEngine in _QuantLib:
_QuantLib.AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister(AnalyticDiscreteGeometricAverageStrikeAsianEngine)

class MCPRDiscreteArithmeticAPEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRDiscreteArithmeticAPEngine_swiginit(self, _QuantLib.new_MCPRDiscreteArithmeticAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteArithmeticAPEngine

# Register MCPRDiscreteArithmeticAPEngine in _QuantLib:
_QuantLib.MCPRDiscreteArithmeticAPEngine_swigregister(MCPRDiscreteArithmeticAPEngine)

class MCLDDiscreteArithmeticAPEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDDiscreteArithmeticAPEngine_swiginit(self, _QuantLib.new_MCLDDiscreteArithmeticAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteArithmeticAPEngine

# Register MCLDDiscreteArithmeticAPEngine in _QuantLib:
_QuantLib.MCLDDiscreteArithmeticAPEngine_swigregister(MCLDDiscreteArithmeticAPEngine)


def MCDiscreteArithmeticAPEngine(process,
                                 traits,
                                 brownianBridge=False,
                                 antitheticVariate=False,
                                 controlVariate=False,
                                 requiredSamples=None,
                                 requiredTolerance=None,
                                 maxSamples=None,
                                 seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteArithmeticAPEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteArithmeticAPEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               controlVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRDiscreteArithmeticASEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRDiscreteArithmeticASEngine_swiginit(self, _QuantLib.new_MCPRDiscreteArithmeticASEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteArithmeticASEngine

# Register MCPRDiscreteArithmeticASEngine in _QuantLib:
_QuantLib.MCPRDiscreteArithmeticASEngine_swigregister(MCPRDiscreteArithmeticASEngine)

class MCLDDiscreteArithmeticASEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDDiscreteArithmeticASEngine_swiginit(self, _QuantLib.new_MCLDDiscreteArithmeticASEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteArithmeticASEngine

# Register MCLDDiscreteArithmeticASEngine in _QuantLib:
_QuantLib.MCLDDiscreteArithmeticASEngine_swigregister(MCLDDiscreteArithmeticASEngine)


def MCDiscreteArithmeticASEngine(process,
                                 traits,
                                 brownianBridge=False,
                                 antitheticVariate=False,
                                 requiredSamples=None,
                                 requiredTolerance=None,
                                 maxSamples=None,
                                 seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteArithmeticASEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteArithmeticASEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRDiscreteGeometricAPEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRDiscreteGeometricAPEngine_swiginit(self, _QuantLib.new_MCPRDiscreteGeometricAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRDiscreteGeometricAPEngine

# Register MCPRDiscreteGeometricAPEngine in _QuantLib:
_QuantLib.MCPRDiscreteGeometricAPEngine_swigregister(MCPRDiscreteGeometricAPEngine)

class MCLDDiscreteGeometricAPEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDDiscreteGeometricAPEngine_swiginit(self, _QuantLib.new_MCLDDiscreteGeometricAPEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDDiscreteGeometricAPEngine

# Register MCLDDiscreteGeometricAPEngine in _QuantLib:
_QuantLib.MCLDDiscreteGeometricAPEngine_swigregister(MCLDDiscreteGeometricAPEngine)


def MCDiscreteGeometricAPEngine(process,
                                 traits,
                                 brownianBridge=False,
                                 antitheticVariate=False,
                                 requiredSamples=None,
                                 requiredTolerance=None,
                                 maxSamples=None,
                                 seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRDiscreteGeometricAPEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDDiscreteGeometricAPEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class VarianceGammaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.VarianceGammaEngine_swiginit(self, _QuantLib.new_VarianceGammaEngine(process))
    __swig_destroy__ = _QuantLib.delete_VarianceGammaEngine

# Register VarianceGammaEngine in _QuantLib:
_QuantLib.VarianceGammaEngine_swigregister(VarianceGammaEngine)

class FFTVarianceGammaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, logStrikeSpacing=0.001):
        _QuantLib.FFTVarianceGammaEngine_swiginit(self, _QuantLib.new_FFTVarianceGammaEngine(process, logStrikeSpacing))

    def precalculate(self, optionList):
        return _QuantLib.FFTVarianceGammaEngine_precalculate(self, optionList)
    __swig_destroy__ = _QuantLib.delete_FFTVarianceGammaEngine

# Register FFTVarianceGammaEngine in _QuantLib:
_QuantLib.FFTVarianceGammaEngine_swigregister(FFTVarianceGammaEngine)

class DoubleBarrierOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise):
        _QuantLib.DoubleBarrierOption_swiginit(self, _QuantLib.new_DoubleBarrierOption(barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_DoubleBarrierOption

# Register DoubleBarrierOption in _QuantLib:
_QuantLib.DoubleBarrierOption_swigregister(DoubleBarrierOption)

class QuantoDoubleBarrierOption(DoubleBarrierOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise):
        _QuantLib.QuantoDoubleBarrierOption_swiginit(self, _QuantLib.new_QuantoDoubleBarrierOption(barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise))

    def qvega(self):
        return _QuantLib.QuantoDoubleBarrierOption_qvega(self)

    def qrho(self):
        return _QuantLib.QuantoDoubleBarrierOption_qrho(self)

    def qlambda(self):
        return _QuantLib.QuantoDoubleBarrierOption_qlambda(self)
    __swig_destroy__ = _QuantLib.delete_QuantoDoubleBarrierOption

# Register QuantoDoubleBarrierOption in _QuantLib:
_QuantLib.QuantoDoubleBarrierOption_swigregister(QuantoDoubleBarrierOption)

class AnalyticDoubleBarrierEngine(PricingEngine):
    r"""Double barrier engine implementing Ikeda-Kunitomo series."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, series=5):
        r"""Double barrier engine implementing Ikeda-Kunitomo series."""
        _QuantLib.AnalyticDoubleBarrierEngine_swiginit(self, _QuantLib.new_AnalyticDoubleBarrierEngine(process, series))
    __swig_destroy__ = _QuantLib.delete_AnalyticDoubleBarrierEngine

# Register AnalyticDoubleBarrierEngine in _QuantLib:
_QuantLib.AnalyticDoubleBarrierEngine_swigregister(AnalyticDoubleBarrierEngine)

class FdHestonDoubleBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdHestonDoubleBarrierEngine_swiginit(self, _QuantLib.new_FdHestonDoubleBarrierEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHestonDoubleBarrierEngine

# Register FdHestonDoubleBarrierEngine in _QuantLib:
_QuantLib.FdHestonDoubleBarrierEngine_swigregister(FdHestonDoubleBarrierEngine)

class WulinYongDoubleBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, series=5):
        _QuantLib.WulinYongDoubleBarrierEngine_swiginit(self, _QuantLib.new_WulinYongDoubleBarrierEngine(process, series))
    __swig_destroy__ = _QuantLib.delete_WulinYongDoubleBarrierEngine

# Register WulinYongDoubleBarrierEngine in _QuantLib:
_QuantLib.WulinYongDoubleBarrierEngine_swigregister(WulinYongDoubleBarrierEngine)

class DeltaVolQuote(Quote):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Spot = _QuantLib.DeltaVolQuote_Spot
    Fwd = _QuantLib.DeltaVolQuote_Fwd
    PaSpot = _QuantLib.DeltaVolQuote_PaSpot
    PaFwd = _QuantLib.DeltaVolQuote_PaFwd
    AtmNull = _QuantLib.DeltaVolQuote_AtmNull
    AtmSpot = _QuantLib.DeltaVolQuote_AtmSpot
    AtmFwd = _QuantLib.DeltaVolQuote_AtmFwd
    AtmDeltaNeutral = _QuantLib.DeltaVolQuote_AtmDeltaNeutral
    AtmVegaMax = _QuantLib.DeltaVolQuote_AtmVegaMax
    AtmGammaMax = _QuantLib.DeltaVolQuote_AtmGammaMax
    AtmPutCall50 = _QuantLib.DeltaVolQuote_AtmPutCall50

    def __init__(self, *args):
        _QuantLib.DeltaVolQuote_swiginit(self, _QuantLib.new_DeltaVolQuote(*args))
    __swig_destroy__ = _QuantLib.delete_DeltaVolQuote

# Register DeltaVolQuote in _QuantLib:
_QuantLib.DeltaVolQuote_swigregister(DeltaVolQuote)

class DeltaVolQuoteHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DeltaVolQuoteHandle_swiginit(self, _QuantLib.new_DeltaVolQuoteHandle(*args))

    def __deref__(self):
        return _QuantLib.DeltaVolQuoteHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.DeltaVolQuoteHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.DeltaVolQuoteHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.DeltaVolQuoteHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.DeltaVolQuoteHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_DeltaVolQuoteHandle

    def value(self):
        return _QuantLib.DeltaVolQuoteHandle_value(self)

    def isValid(self):
        return _QuantLib.DeltaVolQuoteHandle_isValid(self)

# Register DeltaVolQuoteHandle in _QuantLib:
_QuantLib.DeltaVolQuoteHandle_swigregister(DeltaVolQuoteHandle)

class RelinkableDeltaVolQuoteHandle(DeltaVolQuoteHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableDeltaVolQuoteHandle_swiginit(self, _QuantLib.new_RelinkableDeltaVolQuoteHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableDeltaVolQuoteHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableDeltaVolQuoteHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableDeltaVolQuoteHandle

# Register RelinkableDeltaVolQuoteHandle in _QuantLib:
_QuantLib.RelinkableDeltaVolQuoteHandle_swigregister(RelinkableDeltaVolQuoteHandle)

class VannaVolgaIKDoubleBarrierEngine(PricingEngine):
    r"""

    Vanna-Volga engine for double barrier options.
    Supports different double barrier engines, selected by the type parameters.
    Type values:
        ik or analytic:  Ikeda-Kunitomo standard engine (default)
        wo:              Wulin-Yong engine

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta=False, bsPriceWithSmile=0.0, series=5):
        r"""

        Vanna-Volga engine for double barrier options.
        Supports different double barrier engines, selected by the type parameters.
        Type values:
            ik or analytic:  Ikeda-Kunitomo standard engine (default)
            wo:              Wulin-Yong engine

        """
        _QuantLib.VannaVolgaIKDoubleBarrierEngine_swiginit(self, _QuantLib.new_VannaVolgaIKDoubleBarrierEngine(atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta, bsPriceWithSmile, series))
    __swig_destroy__ = _QuantLib.delete_VannaVolgaIKDoubleBarrierEngine

# Register VannaVolgaIKDoubleBarrierEngine in _QuantLib:
_QuantLib.VannaVolgaIKDoubleBarrierEngine_swigregister(VannaVolgaIKDoubleBarrierEngine)

class VannaVolgaWODoubleBarrierEngine(PricingEngine):
    r"""

    Vanna-Volga engine for double barrier options.
    Supports different double barrier engines, selected by the type parameters.
    Type values:
        ik or analytic:  Ikeda-Kunitomo standard engine (default)
        wo:              Wulin-Yong engine

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta=False, bsPriceWithSmile=0.0, series=5):
        r"""

        Vanna-Volga engine for double barrier options.
        Supports different double barrier engines, selected by the type parameters.
        Type values:
            ik or analytic:  Ikeda-Kunitomo standard engine (default)
            wo:              Wulin-Yong engine

        """
        _QuantLib.VannaVolgaWODoubleBarrierEngine_swiginit(self, _QuantLib.new_VannaVolgaWODoubleBarrierEngine(atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta, bsPriceWithSmile, series))
    __swig_destroy__ = _QuantLib.delete_VannaVolgaWODoubleBarrierEngine

# Register VannaVolgaWODoubleBarrierEngine in _QuantLib:
_QuantLib.VannaVolgaWODoubleBarrierEngine_swigregister(VannaVolgaWODoubleBarrierEngine)

class VannaVolgaBarrierEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta=False, bsPriceWithSmile=0.0):
        _QuantLib.VannaVolgaBarrierEngine_swiginit(self, _QuantLib.new_VannaVolgaBarrierEngine(atmVol, vol25Put, vol25Call, spotFX, domesticTS, foreignTS, adaptVanDelta, bsPriceWithSmile))
    __swig_destroy__ = _QuantLib.delete_VannaVolgaBarrierEngine

# Register VannaVolgaBarrierEngine in _QuantLib:
_QuantLib.VannaVolgaBarrierEngine_swigregister(VannaVolgaBarrierEngine)

class AnalyticDoubleBarrierBinaryEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticDoubleBarrierBinaryEngine_swiginit(self, _QuantLib.new_AnalyticDoubleBarrierBinaryEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticDoubleBarrierBinaryEngine

# Register AnalyticDoubleBarrierBinaryEngine in _QuantLib:
_QuantLib.AnalyticDoubleBarrierBinaryEngine_swigregister(AnalyticDoubleBarrierBinaryEngine)

class BinomialCRRDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialCRRDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialCRRDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRDoubleBarrierEngine

# Register BinomialCRRDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialCRRDoubleBarrierEngine_swigregister(BinomialCRRDoubleBarrierEngine)

class BinomialJRDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialJRDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialJRDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRDoubleBarrierEngine

# Register BinomialJRDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialJRDoubleBarrierEngine_swigregister(BinomialJRDoubleBarrierEngine)

class BinomialEQPDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialEQPDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialEQPDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPDoubleBarrierEngine

# Register BinomialEQPDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialEQPDoubleBarrierEngine_swigregister(BinomialEQPDoubleBarrierEngine)

class BinomialTrigeorgisDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialTrigeorgisDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisDoubleBarrierEngine

# Register BinomialTrigeorgisDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisDoubleBarrierEngine_swigregister(BinomialTrigeorgisDoubleBarrierEngine)

class BinomialTianDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialTianDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialTianDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianDoubleBarrierEngine

# Register BinomialTianDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialTianDoubleBarrierEngine_swigregister(BinomialTianDoubleBarrierEngine)

class BinomialLRDoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialLRDoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialLRDoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRDoubleBarrierEngine

# Register BinomialLRDoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialLRDoubleBarrierEngine_swigregister(BinomialLRDoubleBarrierEngine)

class BinomialJ4DoubleBarrierEngine(PricingEngine):
    r"""
    Binomial Engine for double barrier options.
    Features different binomial models, selected by the type parameters.
    Uses Derman-Kani optimization to speed up convergence.
    Type values:
        crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
        jr  or jarrowrudd:               Jarrow-Rudd model
        eqp or additiveeqpbinomialtree:  Additive EQP model
        trigeorgis:                      Trigeorgis model
        tian:                            Tian model
        lr  or leisenreimer              Leisen-Reimer model
        j4  or joshi4:                   Joshi 4th (smoothed) model

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        r"""
        Binomial Engine for double barrier options.
        Features different binomial models, selected by the type parameters.
        Uses Derman-Kani optimization to speed up convergence.
        Type values:
            crr or coxrossrubinstein:        Cox-Ross-Rubinstein model
            jr  or jarrowrudd:               Jarrow-Rudd model
            eqp or additiveeqpbinomialtree:  Additive EQP model
            trigeorgis:                      Trigeorgis model
            tian:                            Tian model
            lr  or leisenreimer              Leisen-Reimer model
            j4  or joshi4:                   Joshi 4th (smoothed) model

        """
        _QuantLib.BinomialJ4DoubleBarrierEngine_swiginit(self, _QuantLib.new_BinomialJ4DoubleBarrierEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4DoubleBarrierEngine

# Register BinomialJ4DoubleBarrierEngine in _QuantLib:
_QuantLib.BinomialJ4DoubleBarrierEngine_swigregister(BinomialJ4DoubleBarrierEngine)


def BinomialDoubleBarrierEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRDoubleBarrierEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRDoubleBarrierEngine
    elif type == "eqp":
        cls = BinomialEQPDoubleBarrierEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisDoubleBarrierEngine
    elif type == "tian":
        cls = BinomialTianDoubleBarrierEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRDoubleBarrierEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4DoubleBarrierEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class VanillaSwingOption(OneAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, ex, minExerciseRights, maxExerciseRights):
        _QuantLib.VanillaSwingOption_swiginit(self, _QuantLib.new_VanillaSwingOption(payoff, ex, minExerciseRights, maxExerciseRights))
    __swig_destroy__ = _QuantLib.delete_VanillaSwingOption

# Register VanillaSwingOption in _QuantLib:
_QuantLib.VanillaSwingOption_swigregister(VanillaSwingOption)

class FdSimpleBSSwingEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdSimpleBSSwingEngine_swiginit(self, _QuantLib.new_FdSimpleBSSwingEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdSimpleBSSwingEngine

# Register FdSimpleBSSwingEngine in _QuantLib:
_QuantLib.FdSimpleBSSwingEngine_swigregister(FdSimpleBSSwingEngine)

class FdSimpleExtOUJumpSwingEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdSimpleExtOUJumpSwingEngine_swiginit(self, _QuantLib.new_FdSimpleExtOUJumpSwingEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdSimpleExtOUJumpSwingEngine

# Register FdSimpleExtOUJumpSwingEngine in _QuantLib:
_QuantLib.FdSimpleExtOUJumpSwingEngine_swigregister(FdSimpleExtOUJumpSwingEngine)

class GJRGARCHModel(CalibratedModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.GJRGARCHModel_swiginit(self, _QuantLib.new_GJRGARCHModel(process))

    def omega(self):
        return _QuantLib.GJRGARCHModel_omega(self)

    def alpha(self):
        return _QuantLib.GJRGARCHModel_alpha(self)

    def beta(self):
        return _QuantLib.GJRGARCHModel_beta(self)

    def gamma(self):
        return _QuantLib.GJRGARCHModel_gamma(self)

    def lambda_parameter(self):
        return _QuantLib.GJRGARCHModel_lambda_parameter(self)

    def v0(self):
        return _QuantLib.GJRGARCHModel_v0(self)
    __swig_destroy__ = _QuantLib.delete_GJRGARCHModel

# Register GJRGARCHModel in _QuantLib:
_QuantLib.GJRGARCHModel_swigregister(GJRGARCHModel)

class AnalyticGJRGARCHEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.AnalyticGJRGARCHEngine_swiginit(self, _QuantLib.new_AnalyticGJRGARCHEngine(process))
    __swig_destroy__ = _QuantLib.delete_AnalyticGJRGARCHEngine

# Register AnalyticGJRGARCHEngine in _QuantLib:
_QuantLib.AnalyticGJRGARCHEngine_swigregister(AnalyticGJRGARCHEngine)

class MCPREuropeanGJRGARCHEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPREuropeanGJRGARCHEngine_swiginit(self, _QuantLib.new_MCPREuropeanGJRGARCHEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanGJRGARCHEngine

# Register MCPREuropeanGJRGARCHEngine in _QuantLib:
_QuantLib.MCPREuropeanGJRGARCHEngine_swigregister(MCPREuropeanGJRGARCHEngine)

class MCLDEuropeanGJRGARCHEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDEuropeanGJRGARCHEngine_swiginit(self, _QuantLib.new_MCLDEuropeanGJRGARCHEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanGJRGARCHEngine

# Register MCLDEuropeanGJRGARCHEngine in _QuantLib:
_QuantLib.MCLDEuropeanGJRGARCHEngine_swigregister(MCLDEuropeanGJRGARCHEngine)


def MCEuropeanGJRGARCHEngine(process,
                             traits,
                             timeSteps=None,
                             timeStepsPerYear=None,
                             antitheticVariate=False,
                             requiredSamples=None,
                             requiredTolerance=None,
                             maxSamples=None,
                             seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanGJRGARCHEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanGJRGARCHEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class SpreadOption(MultiAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        _QuantLib.SpreadOption_swiginit(self, _QuantLib.new_SpreadOption(payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_SpreadOption

# Register SpreadOption in _QuantLib:
_QuantLib.SpreadOption_swigregister(SpreadOption)

class KirkSpreadOptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process1, process2, correlation):
        _QuantLib.KirkSpreadOptionEngine_swiginit(self, _QuantLib.new_KirkSpreadOptionEngine(process1, process2, correlation))
    __swig_destroy__ = _QuantLib.delete_KirkSpreadOptionEngine

# Register KirkSpreadOptionEngine in _QuantLib:
_QuantLib.KirkSpreadOptionEngine_swigregister(KirkSpreadOptionEngine)

class PlainVanillaPayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, strike):
        _QuantLib.PlainVanillaPayoff_swiginit(self, _QuantLib.new_PlainVanillaPayoff(type, strike))
    __swig_destroy__ = _QuantLib.delete_PlainVanillaPayoff

# Register PlainVanillaPayoff in _QuantLib:
_QuantLib.PlainVanillaPayoff_swigregister(PlainVanillaPayoff)


def as_plain_vanilla_payoff(payoff):
    return _QuantLib.as_plain_vanilla_payoff(payoff)
class PercentageStrikePayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, moneyness):
        _QuantLib.PercentageStrikePayoff_swiginit(self, _QuantLib.new_PercentageStrikePayoff(type, moneyness))
    __swig_destroy__ = _QuantLib.delete_PercentageStrikePayoff

# Register PercentageStrikePayoff in _QuantLib:
_QuantLib.PercentageStrikePayoff_swigregister(PercentageStrikePayoff)

class CashOrNothingPayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, strike, payoff):
        _QuantLib.CashOrNothingPayoff_swiginit(self, _QuantLib.new_CashOrNothingPayoff(type, strike, payoff))
    __swig_destroy__ = _QuantLib.delete_CashOrNothingPayoff

# Register CashOrNothingPayoff in _QuantLib:
_QuantLib.CashOrNothingPayoff_swigregister(CashOrNothingPayoff)

class AssetOrNothingPayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, strike):
        _QuantLib.AssetOrNothingPayoff_swiginit(self, _QuantLib.new_AssetOrNothingPayoff(type, strike))
    __swig_destroy__ = _QuantLib.delete_AssetOrNothingPayoff

# Register AssetOrNothingPayoff in _QuantLib:
_QuantLib.AssetOrNothingPayoff_swigregister(AssetOrNothingPayoff)

class SuperSharePayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, strike, increment):
        _QuantLib.SuperSharePayoff_swiginit(self, _QuantLib.new_SuperSharePayoff(type, strike, increment))
    __swig_destroy__ = _QuantLib.delete_SuperSharePayoff

# Register SuperSharePayoff in _QuantLib:
_QuantLib.SuperSharePayoff_swigregister(SuperSharePayoff)

class GapPayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, strike, strikePayoff):
        _QuantLib.GapPayoff_swiginit(self, _QuantLib.new_GapPayoff(type, strike, strikePayoff))
    __swig_destroy__ = _QuantLib.delete_GapPayoff

# Register GapPayoff in _QuantLib:
_QuantLib.GapPayoff_swigregister(GapPayoff)

class VanillaForwardPayoff(StrikedTypePayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, strike):
        _QuantLib.VanillaForwardPayoff_swiginit(self, _QuantLib.new_VanillaForwardPayoff(type, strike))
    __swig_destroy__ = _QuantLib.delete_VanillaForwardPayoff

# Register VanillaForwardPayoff in _QuantLib:
_QuantLib.VanillaForwardPayoff_swigregister(VanillaForwardPayoff)

class BasketPayoff(Payoff):
    thisown = 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_BasketPayoff

# Register BasketPayoff in _QuantLib:
_QuantLib.BasketPayoff_swigregister(BasketPayoff)

class MinBasketPayoff(BasketPayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p):
        _QuantLib.MinBasketPayoff_swiginit(self, _QuantLib.new_MinBasketPayoff(p))
    __swig_destroy__ = _QuantLib.delete_MinBasketPayoff

# Register MinBasketPayoff in _QuantLib:
_QuantLib.MinBasketPayoff_swigregister(MinBasketPayoff)

class MaxBasketPayoff(BasketPayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p):
        _QuantLib.MaxBasketPayoff_swiginit(self, _QuantLib.new_MaxBasketPayoff(p))
    __swig_destroy__ = _QuantLib.delete_MaxBasketPayoff

# Register MaxBasketPayoff in _QuantLib:
_QuantLib.MaxBasketPayoff_swigregister(MaxBasketPayoff)

class AverageBasketPayoff(BasketPayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.AverageBasketPayoff_swiginit(self, _QuantLib.new_AverageBasketPayoff(*args))
    __swig_destroy__ = _QuantLib.delete_AverageBasketPayoff

# Register AverageBasketPayoff in _QuantLib:
_QuantLib.AverageBasketPayoff_swigregister(AverageBasketPayoff)

class SpreadBasketPayoff(BasketPayoff):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p):
        _QuantLib.SpreadBasketPayoff_swiginit(self, _QuantLib.new_SpreadBasketPayoff(p))
    __swig_destroy__ = _QuantLib.delete_SpreadBasketPayoff

# Register SpreadBasketPayoff in _QuantLib:
_QuantLib.SpreadBasketPayoff_swigregister(SpreadBasketPayoff)

class BasketOption(MultiAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        _QuantLib.BasketOption_swiginit(self, _QuantLib.new_BasketOption(payoff, exercise))
    __swig_destroy__ = _QuantLib.delete_BasketOption

# Register BasketOption in _QuantLib:
_QuantLib.BasketOption_swigregister(BasketOption)

class MCPREuropeanBasketEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPREuropeanBasketEngine_swiginit(self, _QuantLib.new_MCPREuropeanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREuropeanBasketEngine

# Register MCPREuropeanBasketEngine in _QuantLib:
_QuantLib.MCPREuropeanBasketEngine_swigregister(MCPREuropeanBasketEngine)

class MCLDEuropeanBasketEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDEuropeanBasketEngine_swiginit(self, _QuantLib.new_MCLDEuropeanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEuropeanBasketEngine

# Register MCLDEuropeanBasketEngine in _QuantLib:
_QuantLib.MCLDEuropeanBasketEngine_swigregister(MCLDEuropeanBasketEngine)


def MCEuropeanBasketEngine(process,
                           traits,
                           timeSteps=None,
                           timeStepsPerYear=None,
                           brownianBridge=False,
                           antitheticVariate=False,
                           requiredSamples=None,
                           requiredTolerance=None,
                           maxSamples=None,
                           seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREuropeanBasketEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEuropeanBasketEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class MCPRAmericanBasketEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRAmericanBasketEngine_swiginit(self, _QuantLib.new_MCPRAmericanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRAmericanBasketEngine

# Register MCPRAmericanBasketEngine in _QuantLib:
_QuantLib.MCPRAmericanBasketEngine_swigregister(MCPRAmericanBasketEngine)

class MCLDAmericanBasketEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDAmericanBasketEngine_swiginit(self, _QuantLib.new_MCLDAmericanBasketEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDAmericanBasketEngine

# Register MCLDAmericanBasketEngine in _QuantLib:
_QuantLib.MCLDAmericanBasketEngine_swigregister(MCLDAmericanBasketEngine)


def MCAmericanBasketEngine(process,
                           traits,
                           timeSteps=None,
                           timeStepsPerYear=None,
                           brownianBridge=False,
                           antitheticVariate=False,
                           requiredSamples=None,
                           requiredTolerance=None,
                           maxSamples=None,
                           seed=0,
                           nCalibrationSamples=2048,
                           polynomOrder=2,
                           polynomType=LsmBasisSystem.Monomial):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRAmericanBasketEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDAmericanBasketEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed,
               nCalibrationSamples,
               polynomOrder,
               polynomType)

class StulzEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process1, process2, correlation):
        _QuantLib.StulzEngine_swiginit(self, _QuantLib.new_StulzEngine(process1, process2, correlation))
    __swig_destroy__ = _QuantLib.delete_StulzEngine

# Register StulzEngine in _QuantLib:
_QuantLib.StulzEngine_swigregister(StulzEngine)

class KirkEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process1, process2, correlation):
        _QuantLib.KirkEngine_swiginit(self, _QuantLib.new_KirkEngine(process1, process2, correlation))
    __swig_destroy__ = _QuantLib.delete_KirkEngine

# Register KirkEngine in _QuantLib:
_QuantLib.KirkEngine_swigregister(KirkEngine)

class Fd2dBlackScholesVanillaEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Fd2dBlackScholesVanillaEngine_swiginit(self, _QuantLib.new_Fd2dBlackScholesVanillaEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Fd2dBlackScholesVanillaEngine

# Register Fd2dBlackScholesVanillaEngine in _QuantLib:
_QuantLib.Fd2dBlackScholesVanillaEngine_swigregister(Fd2dBlackScholesVanillaEngine)

class EverestOption(MultiAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, notional, guarantee, exercise):
        _QuantLib.EverestOption_swiginit(self, _QuantLib.new_EverestOption(notional, guarantee, exercise))
    __swig_destroy__ = _QuantLib.delete_EverestOption

# Register EverestOption in _QuantLib:
_QuantLib.EverestOption_swigregister(EverestOption)

class MCPREverestEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPREverestEngine_swiginit(self, _QuantLib.new_MCPREverestEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPREverestEngine

# Register MCPREverestEngine in _QuantLib:
_QuantLib.MCPREverestEngine_swigregister(MCPREverestEngine)

class MCLDEverestEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDEverestEngine_swiginit(self, _QuantLib.new_MCLDEverestEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDEverestEngine

# Register MCLDEverestEngine in _QuantLib:
_QuantLib.MCLDEverestEngine_swigregister(MCLDEverestEngine)


def MCEverestEngine(process,
                    traits,
                    timeSteps=None,
                    timeStepsPerYear=None,
                    brownianBridge=False,
                    antitheticVariate=False,
                    requiredSamples=None,
                    requiredTolerance=None,
                    maxSamples=None,
                    seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPREverestEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDEverestEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               timeSteps,
               timeStepsPerYear,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)

class HimalayaOption(MultiAssetOption):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, fixingDates, strike):
        _QuantLib.HimalayaOption_swiginit(self, _QuantLib.new_HimalayaOption(fixingDates, strike))
    __swig_destroy__ = _QuantLib.delete_HimalayaOption

# Register HimalayaOption in _QuantLib:
_QuantLib.HimalayaOption_swigregister(HimalayaOption)

class MCPRHimalayaEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCPRHimalayaEngine_swiginit(self, _QuantLib.new_MCPRHimalayaEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCPRHimalayaEngine

# Register MCPRHimalayaEngine in _QuantLib:
_QuantLib.MCPRHimalayaEngine_swigregister(MCPRHimalayaEngine)

class MCLDHimalayaEngine(PricingEngine):
    thisown = 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):
        _QuantLib.MCLDHimalayaEngine_swiginit(self, _QuantLib.new_MCLDHimalayaEngine(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_MCLDHimalayaEngine

# Register MCLDHimalayaEngine in _QuantLib:
_QuantLib.MCLDHimalayaEngine_swigregister(MCLDHimalayaEngine)


def MCHimalayaEngine(process,
                     traits,
                     brownianBridge=False,
                     antitheticVariate=False,
                     requiredSamples=None,
                     requiredTolerance=None,
                     maxSamples=None,
                     seed=0):
    traits = traits.lower()
    if traits == "pr" or traits == "pseudorandom":
        cls = MCPRHimalayaEngine
    elif traits == "ld" or traits == "lowdiscrepancy":
        cls = MCLDHimalayaEngine
    else:
        raise RuntimeError("unknown MC traits: %s" % traits);
    return cls(process,
               brownianBridge,
               antitheticVariate,
               requiredSamples,
               requiredTolerance,
               maxSamples,
               seed)


def blackFormula(optionType, strike, forward, stdDev, discount=1.0, displacement=0.0):
    return _QuantLib.blackFormula(optionType, strike, forward, stdDev, discount, displacement)

def blackFormulaImpliedStdDev(*args):
    return _QuantLib.blackFormulaImpliedStdDev(*args)

def blackFormulaImpliedStdDevLiRS(*args):
    return _QuantLib.blackFormulaImpliedStdDevLiRS(*args)

def blackFormulaCashItmProbability(*args):
    return _QuantLib.blackFormulaCashItmProbability(*args)

def blackFormulaAssetItmProbability(*args):
    return _QuantLib.blackFormulaAssetItmProbability(*args)

def bachelierBlackFormula(optionType, strike, forward, stdDev, discount=1.0):
    return _QuantLib.bachelierBlackFormula(optionType, strike, forward, stdDev, discount)

def bachelierBlackFormulaImpliedVol(optionType, strike, forward, tte, bachelierPrice, discount=1.0):
    return _QuantLib.bachelierBlackFormulaImpliedVol(optionType, strike, forward, tte, bachelierPrice, discount)

def bachelierBlackFormulaAssetItmProbability(*args):
    return _QuantLib.bachelierBlackFormulaAssetItmProbability(*args)
class BlackDeltaCalculator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ot, dt, spot, dDiscount, fDiscount, stDev):
        _QuantLib.BlackDeltaCalculator_swiginit(self, _QuantLib.new_BlackDeltaCalculator(ot, dt, spot, dDiscount, fDiscount, stDev))

    def deltaFromStrike(self, strike):
        return _QuantLib.BlackDeltaCalculator_deltaFromStrike(self, strike)

    def strikeFromDelta(self, delta):
        return _QuantLib.BlackDeltaCalculator_strikeFromDelta(self, delta)

    def atmStrike(self, atmT):
        return _QuantLib.BlackDeltaCalculator_atmStrike(self, atmT)
    __swig_destroy__ = _QuantLib.delete_BlackDeltaCalculator

# Register BlackDeltaCalculator in _QuantLib:
_QuantLib.BlackDeltaCalculator_swigregister(BlackDeltaCalculator)

class CallabilityPrice(object):
    thisown = 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, amount, type):
        _QuantLib.CallabilityPrice_swiginit(self, _QuantLib.new_CallabilityPrice(amount, type))

    def amount(self):
        return _QuantLib.CallabilityPrice_amount(self)

    def type(self):
        return _QuantLib.CallabilityPrice_type(self)
    __swig_destroy__ = _QuantLib.delete_CallabilityPrice

# Register CallabilityPrice in _QuantLib:
_QuantLib.CallabilityPrice_swigregister(CallabilityPrice)

class Callability(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Call = _QuantLib.Callability_Call
    Put = _QuantLib.Callability_Put

    def __init__(self, price, type, date):
        _QuantLib.Callability_swiginit(self, _QuantLib.new_Callability(price, type, date))

    def price(self):
        return _QuantLib.Callability_price(self)

    def type(self):
        return _QuantLib.Callability_type(self)

    def date(self):
        return _QuantLib.Callability_date(self)
    __swig_destroy__ = _QuantLib.delete_Callability

# Register Callability in _QuantLib:
_QuantLib.Callability_swigregister(Callability)

class SoftCallability(Callability):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, price, date, trigger):
        _QuantLib.SoftCallability_swiginit(self, _QuantLib.new_SoftCallability(price, date, trigger))
    __swig_destroy__ = _QuantLib.delete_SoftCallability

# Register SoftCallability in _QuantLib:
_QuantLib.SoftCallability_swigregister(SoftCallability)

class CallabilitySchedule(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.CallabilitySchedule___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.CallabilitySchedule___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.CallabilitySchedule___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.CallabilitySchedule_pop(self)

    def append(self, x):
        return _QuantLib.CallabilitySchedule_append(self, x)

    def empty(self):
        return _QuantLib.CallabilitySchedule_empty(self)

    def size(self):
        return _QuantLib.CallabilitySchedule_size(self)

    def swap(self, v):
        return _QuantLib.CallabilitySchedule_swap(self, v)

    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 clear(self):
        return _QuantLib.CallabilitySchedule_clear(self)

    def get_allocator(self):
        return _QuantLib.CallabilitySchedule_get_allocator(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):
        _QuantLib.CallabilitySchedule_swiginit(self, _QuantLib.new_CallabilitySchedule(*args))

    def push_back(self, x):
        return _QuantLib.CallabilitySchedule_push_back(self, x)

    def front(self):
        return _QuantLib.CallabilitySchedule_front(self)

    def back(self):
        return _QuantLib.CallabilitySchedule_back(self)

    def assign(self, n, x):
        return _QuantLib.CallabilitySchedule_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.CallabilitySchedule_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.CallabilitySchedule_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.CallabilitySchedule_reserve(self, n)

    def capacity(self):
        return _QuantLib.CallabilitySchedule_capacity(self)
    __swig_destroy__ = _QuantLib.delete_CallabilitySchedule

# Register CallabilitySchedule in _QuantLib:
_QuantLib.CallabilitySchedule_swigregister(CallabilitySchedule)

class TimeBasket(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.TimeBasket_swiginit(self, _QuantLib.new_TimeBasket(*args))

    def __len__(self):
        return _QuantLib.TimeBasket___len__(self)

    def rebin(self, arg2):
        return _QuantLib.TimeBasket_rebin(self, arg2)

    def __getitem__(self, d):
        return _QuantLib.TimeBasket___getitem__(self, d)

    def __setitem__(self, d, value):
        return _QuantLib.TimeBasket___setitem__(self, d, value)

    def items(self):
        return _QuantLib.TimeBasket_items(self)

    def __contains__(self, d):
        return _QuantLib.TimeBasket___contains__(self, d)

    def __iter__(self):
        return _QuantLib.TimeBasket___iter__(self)
    __swig_destroy__ = _QuantLib.delete_TimeBasket

# Register TimeBasket in _QuantLib:
_QuantLib.TimeBasket_swigregister(TimeBasket)

class Swap(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, firstLeg, secondLeg):
        _QuantLib.Swap_swiginit(self, _QuantLib.new_Swap(firstLeg, secondLeg))

    def startDate(self):
        return _QuantLib.Swap_startDate(self)

    def maturityDate(self):
        return _QuantLib.Swap_maturityDate(self)

    def leg(self, i):
        return _QuantLib.Swap_leg(self, i)

    def legNPV(self, j):
        return _QuantLib.Swap_legNPV(self, j)

    def legBPS(self, k):
        return _QuantLib.Swap_legBPS(self, k)
    __swig_destroy__ = _QuantLib.delete_Swap

# Register Swap in _QuantLib:
_QuantLib.Swap_swigregister(Swap)

class VanillaSwap(Swap):
    thisown = 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, type, nominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, spread, floatingDayCount):
        _QuantLib.VanillaSwap_swiginit(self, _QuantLib.new_VanillaSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, spread, floatingDayCount))

    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)

    def fixedLegNPV(self):
        return _QuantLib.VanillaSwap_fixedLegNPV(self)

    def floatingLegNPV(self):
        return _QuantLib.VanillaSwap_floatingLegNPV(self)

    def fixedLeg(self):
        return _QuantLib.VanillaSwap_fixedLeg(self)

    def floatingLeg(self):
        return _QuantLib.VanillaSwap_floatingLeg(self)

    def nominal(self):
        return _QuantLib.VanillaSwap_nominal(self)

    def fixedSchedule(self):
        return _QuantLib.VanillaSwap_fixedSchedule(self)

    def floatingSchedule(self):
        return _QuantLib.VanillaSwap_floatingSchedule(self)

    def fixedRate(self):
        return _QuantLib.VanillaSwap_fixedRate(self)

    def spread(self):
        return _QuantLib.VanillaSwap_spread(self)

    def floatingDayCount(self):
        return _QuantLib.VanillaSwap_floatingDayCount(self)

    def fixedDayCount(self):
        return _QuantLib.VanillaSwap_fixedDayCount(self)
    __swig_destroy__ = _QuantLib.delete_VanillaSwap

# Register VanillaSwap in _QuantLib:
_QuantLib.VanillaSwap_swigregister(VanillaSwap)

class _MakeVanillaSwap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def receiveFixed(self, flag=True):
        return _QuantLib._MakeVanillaSwap_receiveFixed(self, flag)

    def withType(self, type):
        return _QuantLib._MakeVanillaSwap_withType(self, type)

    def withNominal(self, n):
        return _QuantLib._MakeVanillaSwap_withNominal(self, n)

    def withSettlementDays(self, settlementDays):
        return _QuantLib._MakeVanillaSwap_withSettlementDays(self, settlementDays)

    def withEffectiveDate(self, arg2):
        return _QuantLib._MakeVanillaSwap_withEffectiveDate(self, arg2)

    def withTerminationDate(self, arg2):
        return _QuantLib._MakeVanillaSwap_withTerminationDate(self, arg2)

    def withRule(self, r):
        return _QuantLib._MakeVanillaSwap_withRule(self, r)

    def withFixedLegTenor(self, t):
        return _QuantLib._MakeVanillaSwap_withFixedLegTenor(self, t)

    def withFixedLegCalendar(self, cal):
        return _QuantLib._MakeVanillaSwap_withFixedLegCalendar(self, cal)

    def withFixedLegConvention(self, bdc):
        return _QuantLib._MakeVanillaSwap_withFixedLegConvention(self, bdc)

    def withFixedLegTerminationDateConvention(self, bdc):
        return _QuantLib._MakeVanillaSwap_withFixedLegTerminationDateConvention(self, bdc)

    def withFixedLegRule(self, r):
        return _QuantLib._MakeVanillaSwap_withFixedLegRule(self, r)

    def withFixedLegEndOfMonth(self, flag=True):
        return _QuantLib._MakeVanillaSwap_withFixedLegEndOfMonth(self, flag)

    def withFixedLegFirstDate(self, d):
        return _QuantLib._MakeVanillaSwap_withFixedLegFirstDate(self, d)

    def withFixedLegNextToLastDate(self, d):
        return _QuantLib._MakeVanillaSwap_withFixedLegNextToLastDate(self, d)

    def withFixedLegDayCount(self, dc):
        return _QuantLib._MakeVanillaSwap_withFixedLegDayCount(self, dc)

    def withFloatingLegTenor(self, t):
        return _QuantLib._MakeVanillaSwap_withFloatingLegTenor(self, t)

    def withFloatingLegCalendar(self, cal):
        return _QuantLib._MakeVanillaSwap_withFloatingLegCalendar(self, cal)

    def withFloatingLegConvention(self, bdc):
        return _QuantLib._MakeVanillaSwap_withFloatingLegConvention(self, bdc)

    def withFloatingLegTerminationDateConvention(self, bdc):
        return _QuantLib._MakeVanillaSwap_withFloatingLegTerminationDateConvention(self, bdc)

    def withFloatingLegRule(self, r):
        return _QuantLib._MakeVanillaSwap_withFloatingLegRule(self, r)

    def withFloatingLegEndOfMonth(self, flag=True):
        return _QuantLib._MakeVanillaSwap_withFloatingLegEndOfMonth(self, flag)

    def withFloatingLegFirstDate(self, d):
        return _QuantLib._MakeVanillaSwap_withFloatingLegFirstDate(self, d)

    def withFloatingLegNextToLastDate(self, d):
        return _QuantLib._MakeVanillaSwap_withFloatingLegNextToLastDate(self, d)

    def withFloatingLegDayCount(self, dc):
        return _QuantLib._MakeVanillaSwap_withFloatingLegDayCount(self, dc)

    def withFloatingLegSpread(self, sp):
        return _QuantLib._MakeVanillaSwap_withFloatingLegSpread(self, sp)

    def withDiscountingTermStructure(self, discountCurve):
        return _QuantLib._MakeVanillaSwap_withDiscountingTermStructure(self, discountCurve)

    def withPricingEngine(self, engine):
        return _QuantLib._MakeVanillaSwap_withPricingEngine(self, engine)

    def __init__(self, swapTenor, index, fixedRate, forwardStart):
        _QuantLib._MakeVanillaSwap_swiginit(self, _QuantLib.new__MakeVanillaSwap(swapTenor, index, fixedRate, forwardStart))

    def makeVanillaSwap(self):
        return _QuantLib._MakeVanillaSwap_makeVanillaSwap(self)
    __swig_destroy__ = _QuantLib.delete__MakeVanillaSwap

# Register _MakeVanillaSwap in _QuantLib:
_QuantLib._MakeVanillaSwap_swigregister(_MakeVanillaSwap)


def MakeVanillaSwap(swapTenor, iborIndex, fixedRate, forwardStart,
    receiveFixed=None, swapType=None, Nominal=None, settlementDays=None,
    effectiveDate=None, terminationDate=None, dateGenerationRule=None,
    fixedLegTenor=None, fixedLegCalendar=None, fixedLegConvention=None,
    fixedLegDayCount=None, floatingLegTenor=None, floatingLegCalendar=None,
    floatingLegConvention=None, floatingLegDayCount=None, floatingLegSpread=None,
    discountingTermStructure=None, pricingEngine=None,
    fixedLegTerminationDateConvention=None,  fixedLegDateGenRule=None,
    fixedLegEndOfMonth=None, fixedLegFirstDate=None, fixedLegNextToLastDate=None,
    floatingLegTerminationDateConvention=None,  floatingLegDateGenRule=None,
    floatingLegEndOfMonth=None, floatingLegFirstDate=None, floatingLegNextToLastDate=None):
    mv = _MakeVanillaSwap(swapTenor, iborIndex, fixedRate, forwardStart)
    if receiveFixed is not None:
        mv.receiveFixed(receiveFixed)
    if swapType is not None:
        mv.withType(swapType)
    if Nominal is not None:
        mv.withNominal(Nominal)
    if settlementDays is not None:
        mv.withSettlementDays(settlementDays)
    if effectiveDate is not None:
        mv.withEffectiveDate(effectiveDate)
    if terminationDate is not None:
        mv.withTerminationDate(terminationDate)
    if dateGenerationRule is not None:
        mv.withRule(dateGenerationRule)
    if fixedLegTenor is not None:
        mv.withFixedLegTenor(fixedLegTenor)
    if fixedLegCalendar is not None:
        mv.withFixedLegCalendar(fixedLegCalendar)
    if fixedLegConvention is not None:
        mv.withFixedLegConvention(fixedLegConvention)
    if fixedLegDayCount is not None:
        mv.withFixedLegDayCount(fixedLegDayCount)
    if floatingLegTenor is not None:
        mv.withFloatingLegTenor(floatingLegTenor)
    if floatingLegCalendar is not None:
        mv.withFloatingLegCalendar(floatingLegCalendar)
    if floatingLegConvention is not None:
        mv.withFloatingLegConvention(floatingLegConvention)
    if floatingLegDayCount is not None:
        mv.withFloatingLegDayCount(floatingLegDayCount)
    if floatingLegSpread is not None:
        mv.withFloatingLegSpread(floatingLegSpread)
    if discountingTermStructure is not None:
        mv.withDiscountingTermStructure(discountingTermStructure)
    if pricingEngine is not None:
        mv.withPricingEngine(pricingEngine)
    if fixedLegTerminationDateConvention is not None:
        mv.withFixedLegTerminationDateConvention(fixedLegTerminationDateConvention)
    if fixedLegDateGenRule is not None:
        mv.withFixedLegRule(fixedLegDateGenRule)
    if fixedLegEndOfMonth is not None:
        mv.withFixedLegEndOfMonth(fixedLegEndOfMonth)
    if fixedLegFirstDate is not None:
        mv.withFixedLegFirstDate(fixedLegFirstDate)
    if fixedLegNextToLastDate is not None:
        mv.withFixedLegNextToLastDate(fixedLegNextToLastDate)
    if floatingLegTerminationDateConvention is not None:
        mv.withFloatingLegTerminationDateConvention(floatingLegTerminationDateConvention)
    if floatingLegDateGenRule is not None:
        mv.withFloatingLegRule(floatingLegDateGenRule)
    if floatingLegEndOfMonth is not None:
        mv.withFloatingLegEndOfMonth(floatingLegEndOfMonth)
    if floatingLegFirstDate is not None:
        mv.withFloatingLegFirstDate(floatingLegFirstDate)
    if floatingLegNextToLastDate is not None:
        mv.withFloatingLegNextToLastDate(floatingLegNextToLastDate)
    return mv.makeVanillaSwap()

class NonstandardSwap(Swap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, fixedNominal, floatingNominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, gearing, spread, floatDayCount, intermediateCapitalExchange=False, finalCapitalExchange=False, paymentConvention=Following):
        _QuantLib.NonstandardSwap_swiginit(self, _QuantLib.new_NonstandardSwap(type, fixedNominal, floatingNominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, gearing, spread, floatDayCount, intermediateCapitalExchange, finalCapitalExchange, paymentConvention))

    def type(self):
        return _QuantLib.NonstandardSwap_type(self)

    def fixedNominal(self):
        return _QuantLib.NonstandardSwap_fixedNominal(self)

    def floatingNominal(self):
        return _QuantLib.NonstandardSwap_floatingNominal(self)

    def fixedSchedule(self):
        return _QuantLib.NonstandardSwap_fixedSchedule(self)

    def fixedRate(self):
        return _QuantLib.NonstandardSwap_fixedRate(self)

    def fixedDayCount(self):
        return _QuantLib.NonstandardSwap_fixedDayCount(self)

    def floatingSchedule(self):
        return _QuantLib.NonstandardSwap_floatingSchedule(self)

    def iborIndex(self):
        return _QuantLib.NonstandardSwap_iborIndex(self)

    def spread(self):
        return _QuantLib.NonstandardSwap_spread(self)

    def gearing(self):
        return _QuantLib.NonstandardSwap_gearing(self)

    def spreads(self):
        return _QuantLib.NonstandardSwap_spreads(self)

    def gearings(self):
        return _QuantLib.NonstandardSwap_gearings(self)

    def floatingDayCount(self):
        return _QuantLib.NonstandardSwap_floatingDayCount(self)

    def paymentConvention(self):
        return _QuantLib.NonstandardSwap_paymentConvention(self)

    def fixedLeg(self):
        return _QuantLib.NonstandardSwap_fixedLeg(self)

    def floatingLeg(self):
        return _QuantLib.NonstandardSwap_floatingLeg(self)
    __swig_destroy__ = _QuantLib.delete_NonstandardSwap

# Register NonstandardSwap in _QuantLib:
_QuantLib.NonstandardSwap_swigregister(NonstandardSwap)

class DiscountingSwapEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DiscountingSwapEngine_swiginit(self, _QuantLib.new_DiscountingSwapEngine(*args))
    __swig_destroy__ = _QuantLib.delete_DiscountingSwapEngine

# Register DiscountingSwapEngine in _QuantLib:
_QuantLib.DiscountingSwapEngine_swigregister(DiscountingSwapEngine)

class AssetSwap(Swap):
    thisown = 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):
        _QuantLib.AssetSwap_swiginit(self, _QuantLib.new_AssetSwap(*args, **kwargs))

    def fairCleanPrice(self):
        return _QuantLib.AssetSwap_fairCleanPrice(self)

    def fairSpread(self):
        return _QuantLib.AssetSwap_fairSpread(self)
    __swig_destroy__ = _QuantLib.delete_AssetSwap

# Register AssetSwap in _QuantLib:
_QuantLib.AssetSwap_swigregister(AssetSwap)

class FloatFloatSwap(Swap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FloatFloatSwap_swiginit(self, _QuantLib.new_FloatFloatSwap(*args))
    __swig_destroy__ = _QuantLib.delete_FloatFloatSwap

# Register FloatFloatSwap in _QuantLib:
_QuantLib.FloatFloatSwap_swigregister(FloatFloatSwap)

class OvernightIndexedSwap(Swap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Receiver = _QuantLib.OvernightIndexedSwap_Receiver
    Payer = _QuantLib.OvernightIndexedSwap_Payer

    def __init__(self, *args):
        _QuantLib.OvernightIndexedSwap_swiginit(self, _QuantLib.new_OvernightIndexedSwap(*args))

    def fixedLegBPS(self):
        return _QuantLib.OvernightIndexedSwap_fixedLegBPS(self)

    def fixedLegNPV(self):
        return _QuantLib.OvernightIndexedSwap_fixedLegNPV(self)

    def fairRate(self):
        return _QuantLib.OvernightIndexedSwap_fairRate(self)

    def overnightLegBPS(self):
        return _QuantLib.OvernightIndexedSwap_overnightLegBPS(self)

    def overnightLegNPV(self):
        return _QuantLib.OvernightIndexedSwap_overnightLegNPV(self)

    def fairSpread(self):
        return _QuantLib.OvernightIndexedSwap_fairSpread(self)

    def type(self):
        return _QuantLib.OvernightIndexedSwap_type(self)

    def nominal(self):
        return _QuantLib.OvernightIndexedSwap_nominal(self)

    def nominals(self):
        return _QuantLib.OvernightIndexedSwap_nominals(self)

    def paymentFrequency(self):
        return _QuantLib.OvernightIndexedSwap_paymentFrequency(self)

    def fixedRate(self):
        return _QuantLib.OvernightIndexedSwap_fixedRate(self)

    def fixedDayCount(self):
        return _QuantLib.OvernightIndexedSwap_fixedDayCount(self)

    def spread(self):
        return _QuantLib.OvernightIndexedSwap_spread(self)

    def fixedLeg(self):
        return _QuantLib.OvernightIndexedSwap_fixedLeg(self)

    def overnightLeg(self):
        return _QuantLib.OvernightIndexedSwap_overnightLeg(self)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexedSwap

# Register OvernightIndexedSwap in _QuantLib:
_QuantLib.OvernightIndexedSwap_swigregister(OvernightIndexedSwap)

class _MakeOIS(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib._MakeOIS_swiginit(self, _QuantLib.new__MakeOIS(*args))

    def makeOIS(self):
        return _QuantLib._MakeOIS_makeOIS(self)

    def receiveFixed(self, flag=True):
        return _QuantLib._MakeOIS_receiveFixed(self, flag)

    def withType(self, type):
        return _QuantLib._MakeOIS_withType(self, type)

    def withNominal(self, n):
        return _QuantLib._MakeOIS_withNominal(self, n)

    def withSettlementDays(self, settlementDays):
        return _QuantLib._MakeOIS_withSettlementDays(self, settlementDays)

    def withEffectiveDate(self, arg2):
        return _QuantLib._MakeOIS_withEffectiveDate(self, arg2)

    def withTerminationDate(self, arg2):
        return _QuantLib._MakeOIS_withTerminationDate(self, arg2)

    def withRule(self, r):
        return _QuantLib._MakeOIS_withRule(self, r)

    def withPaymentFrequency(self, f):
        return _QuantLib._MakeOIS_withPaymentFrequency(self, f)

    def withPaymentAdjustment(self, convention):
        return _QuantLib._MakeOIS_withPaymentAdjustment(self, convention)

    def withPaymentLag(self, lag):
        return _QuantLib._MakeOIS_withPaymentLag(self, lag)

    def withPaymentCalendar(self, cal):
        return _QuantLib._MakeOIS_withPaymentCalendar(self, cal)

    def withEndOfMonth(self, flag=True):
        return _QuantLib._MakeOIS_withEndOfMonth(self, flag)

    def withFixedLegDayCount(self, dc):
        return _QuantLib._MakeOIS_withFixedLegDayCount(self, dc)

    def withOvernightLegSpread(self, sp):
        return _QuantLib._MakeOIS_withOvernightLegSpread(self, sp)

    def withDiscountingTermStructure(self, discountingTermStructure):
        return _QuantLib._MakeOIS_withDiscountingTermStructure(self, discountingTermStructure)

    def withTelescopicValueDates(self, telescopicValueDates):
        return _QuantLib._MakeOIS_withTelescopicValueDates(self, telescopicValueDates)

    def withPricingEngine(self, engine):
        return _QuantLib._MakeOIS_withPricingEngine(self, engine)
    __swig_destroy__ = _QuantLib.delete__MakeOIS

# Register _MakeOIS in _QuantLib:
_QuantLib._MakeOIS_swigregister(_MakeOIS)


def MakeOIS(swapTenor, overnightIndex, fixedRate, fwdStart=Period(0, Days),
            receiveFixed=True,
            swapType=OvernightIndexedSwap.Payer,
            nominal=1.0,
            settlementDays=2,
            effectiveDate=None,
            terminationDate=None,
            dateGenerationRule=DateGeneration.Backward,
            paymentFrequency=Annual,
            paymentAdjustmentConvention=Following,
            paymentLag=0,
            paymentCalendar=None,
            endOfMonth=True,    
            fixedLegDayCount=None,
            overnightLegSpread=0.0,
            discountingTermStructure=None,
            telescopicValueDates=False,
            pricingEngine=None):

    mv = _MakeOIS(swapTenor, overnightIndex, fixedRate, fwdStart)

    if not receiveFixed:
        mv.receiveFixed(receiveFixed)
    if swapType != OvernightIndexedSwap.Payer:
        mv.withType(swapType)
    if nominal != 1.0:
        mv.withNominal(nominal)
    if settlementDays != 2:
        mv.withSettlementDays(settlementDays)
    if effectiveDate is not None:
        mv.withEffectiveDate(effectiveDate)
    if terminationDate is not None:
        mv.withTerminationDate(terminationDate)
    if dateGenerationRule != DateGeneration.Backward:
        mv.withRule(dateGenerationRule)  
    if paymentFrequency != Annual:
        mv.withPaymentFrequency(paymentFrequency)
    if paymentAdjustmentConvention != Following:
        mv.withPaymentAdjustment(paymentAdjustmentConvention)
    if paymentLag != 0:
        mv.withPaymentLag(paymentLag)
    if paymentCalendar is not None:
        mv.withPaymentCalendar(paymentCalendar)
    if not endOfMonth:
        mv.withEndOfMonth(endOfMonth)
    if fixedLegDayCount is not None:
        mv.withFixedLegDayCount(fixedLegDayCount)
    else:
        mv.withFixedLegDayCount(overnightIndex.dayCounter())
    if overnightLegSpread != 0.0:
        mv.withOvernightLegSpread(overnightLegSpread)
    if discountingTermStructure is not None:
        mv.withDiscountingTermStructure(discountingTermStructure)        
    if telescopicValueDates:
        mv.withTelescopicValueDates(telescopicValueDates)
    if pricingEngine is not None:
        mv.withPricingEngine(pricingEngine)

    return mv.makeOIS()

class OvernightIndexedSwapIndex(SwapIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, familyName, tenor, settlementDays, currency, overnightIndex, telescopicValueDates=False):
        _QuantLib.OvernightIndexedSwapIndex_swiginit(self, _QuantLib.new_OvernightIndexedSwapIndex(familyName, tenor, settlementDays, currency, overnightIndex, telescopicValueDates))

    def overnightIndex(self):
        return _QuantLib.OvernightIndexedSwapIndex_overnightIndex(self)

    def underlyingSwap(self, fixingDate):
        return _QuantLib.OvernightIndexedSwapIndex_underlyingSwap(self, fixingDate)
    __swig_destroy__ = _QuantLib.delete_OvernightIndexedSwapIndex

# Register OvernightIndexedSwapIndex in _QuantLib:
_QuantLib.OvernightIndexedSwapIndex_swigregister(OvernightIndexedSwapIndex)


def as_overnight_swap_index(index):
    return _QuantLib.as_overnight_swap_index(index)
class Seasonality(object):
    thisown = 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 correctZeroRate(self, d, r, iTS):
        return _QuantLib.Seasonality_correctZeroRate(self, d, r, iTS)

    def correctYoYRate(self, d, r, iTS):
        return _QuantLib.Seasonality_correctYoYRate(self, d, r, iTS)

    def isConsistent(self, iTS):
        return _QuantLib.Seasonality_isConsistent(self, iTS)
    __swig_destroy__ = _QuantLib.delete_Seasonality

# Register Seasonality in _QuantLib:
_QuantLib.Seasonality_swigregister(Seasonality)

class MultiplicativePriceSeasonality(Seasonality):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seasonalityBaseDate, frequency, seasonalityFactors):
        _QuantLib.MultiplicativePriceSeasonality_swiginit(self, _QuantLib.new_MultiplicativePriceSeasonality(seasonalityBaseDate, frequency, seasonalityFactors))
    __swig_destroy__ = _QuantLib.delete_MultiplicativePriceSeasonality

# Register MultiplicativePriceSeasonality in _QuantLib:
_QuantLib.MultiplicativePriceSeasonality_swigregister(MultiplicativePriceSeasonality)

class KerkhofSeasonality(Seasonality):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, seasonalityBaseDate, seasonalityFactors):
        _QuantLib.KerkhofSeasonality_swiginit(self, _QuantLib.new_KerkhofSeasonality(seasonalityBaseDate, seasonalityFactors))
    __swig_destroy__ = _QuantLib.delete_KerkhofSeasonality

# Register KerkhofSeasonality in _QuantLib:
_QuantLib.KerkhofSeasonality_swigregister(KerkhofSeasonality)

class InflationTermStructure(TermStructure):
    thisown = 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 observationLag(self):
        return _QuantLib.InflationTermStructure_observationLag(self)

    def frequency(self):
        return _QuantLib.InflationTermStructure_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.InflationTermStructure_indexIsInterpolated(self)

    def baseRate(self):
        return _QuantLib.InflationTermStructure_baseRate(self)

    def nominalTermStructure(self):
        return _QuantLib.InflationTermStructure_nominalTermStructure(self)

    def baseDate(self):
        return _QuantLib.InflationTermStructure_baseDate(self)

    def setSeasonality(self, *args):
        return _QuantLib.InflationTermStructure_setSeasonality(self, *args)

    def seasonality(self):
        return _QuantLib.InflationTermStructure_seasonality(self)

    def hasSeasonality(self):
        return _QuantLib.InflationTermStructure_hasSeasonality(self)
    __swig_destroy__ = _QuantLib.delete_InflationTermStructure

# Register InflationTermStructure in _QuantLib:
_QuantLib.InflationTermStructure_swigregister(InflationTermStructure)

class YoYInflationTermStructure(InflationTermStructure):
    thisown = 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 yoyRate(self, *args):
        return _QuantLib.YoYInflationTermStructure_yoyRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_YoYInflationTermStructure

# Register YoYInflationTermStructure in _QuantLib:
_QuantLib.YoYInflationTermStructure_swigregister(YoYInflationTermStructure)

class YoYInflationTermStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YoYInflationTermStructureHandle_swiginit(self, _QuantLib.new_YoYInflationTermStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.YoYInflationTermStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.YoYInflationTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.YoYInflationTermStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.YoYInflationTermStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.YoYInflationTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationTermStructureHandle

    def yoyRate(self, *args):
        return _QuantLib.YoYInflationTermStructureHandle_yoyRate(self, *args)

    def observationLag(self):
        return _QuantLib.YoYInflationTermStructureHandle_observationLag(self)

    def frequency(self):
        return _QuantLib.YoYInflationTermStructureHandle_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.YoYInflationTermStructureHandle_indexIsInterpolated(self)

    def baseRate(self):
        return _QuantLib.YoYInflationTermStructureHandle_baseRate(self)

    def nominalTermStructure(self):
        return _QuantLib.YoYInflationTermStructureHandle_nominalTermStructure(self)

    def baseDate(self):
        return _QuantLib.YoYInflationTermStructureHandle_baseDate(self)

    def setSeasonality(self, *args):
        return _QuantLib.YoYInflationTermStructureHandle_setSeasonality(self, *args)

    def seasonality(self):
        return _QuantLib.YoYInflationTermStructureHandle_seasonality(self)

    def hasSeasonality(self):
        return _QuantLib.YoYInflationTermStructureHandle_hasSeasonality(self)

    def dayCounter(self):
        return _QuantLib.YoYInflationTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.YoYInflationTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.YoYInflationTermStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.YoYInflationTermStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.YoYInflationTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.YoYInflationTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.YoYInflationTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YoYInflationTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YoYInflationTermStructureHandle_allowsExtrapolation(self)

# Register YoYInflationTermStructureHandle in _QuantLib:
_QuantLib.YoYInflationTermStructureHandle_swigregister(YoYInflationTermStructureHandle)

class RelinkableYoYInflationTermStructureHandle(YoYInflationTermStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableYoYInflationTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableYoYInflationTermStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableYoYInflationTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableYoYInflationTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableYoYInflationTermStructureHandle

# Register RelinkableYoYInflationTermStructureHandle in _QuantLib:
_QuantLib.RelinkableYoYInflationTermStructureHandle_swigregister(RelinkableYoYInflationTermStructureHandle)

class ZeroInflationTermStructure(InflationTermStructure):
    thisown = 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 zeroRate(self, *args):
        return _QuantLib.ZeroInflationTermStructure_zeroRate(self, *args)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationTermStructure

# Register ZeroInflationTermStructure in _QuantLib:
_QuantLib.ZeroInflationTermStructure_swigregister(ZeroInflationTermStructure)

class ZeroInflationTermStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZeroInflationTermStructureHandle_swiginit(self, _QuantLib.new_ZeroInflationTermStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.ZeroInflationTermStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.ZeroInflationTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.ZeroInflationTermStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.ZeroInflationTermStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.ZeroInflationTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationTermStructureHandle

    def zeroRate(self, *args):
        return _QuantLib.ZeroInflationTermStructureHandle_zeroRate(self, *args)

    def observationLag(self):
        return _QuantLib.ZeroInflationTermStructureHandle_observationLag(self)

    def frequency(self):
        return _QuantLib.ZeroInflationTermStructureHandle_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.ZeroInflationTermStructureHandle_indexIsInterpolated(self)

    def baseRate(self):
        return _QuantLib.ZeroInflationTermStructureHandle_baseRate(self)

    def nominalTermStructure(self):
        return _QuantLib.ZeroInflationTermStructureHandle_nominalTermStructure(self)

    def baseDate(self):
        return _QuantLib.ZeroInflationTermStructureHandle_baseDate(self)

    def setSeasonality(self, *args):
        return _QuantLib.ZeroInflationTermStructureHandle_setSeasonality(self, *args)

    def seasonality(self):
        return _QuantLib.ZeroInflationTermStructureHandle_seasonality(self)

    def hasSeasonality(self):
        return _QuantLib.ZeroInflationTermStructureHandle_hasSeasonality(self)

    def dayCounter(self):
        return _QuantLib.ZeroInflationTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.ZeroInflationTermStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.ZeroInflationTermStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.ZeroInflationTermStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.ZeroInflationTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.ZeroInflationTermStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructureHandle_allowsExtrapolation(self)

# Register ZeroInflationTermStructureHandle in _QuantLib:
_QuantLib.ZeroInflationTermStructureHandle_swigregister(ZeroInflationTermStructureHandle)

class RelinkableZeroInflationTermStructureHandle(ZeroInflationTermStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableZeroInflationTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableZeroInflationTermStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableZeroInflationTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableZeroInflationTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableZeroInflationTermStructureHandle

# Register RelinkableZeroInflationTermStructureHandle in _QuantLib:
_QuantLib.RelinkableZeroInflationTermStructureHandle_swigregister(RelinkableZeroInflationTermStructureHandle)

class Region(object):
    thisown = 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 name(self):
        return _QuantLib.Region_name(self)

    def code(self):
        return _QuantLib.Region_code(self)
    __swig_destroy__ = _QuantLib.delete_Region

# Register Region in _QuantLib:
_QuantLib.Region_swigregister(Region)

class CustomRegion(Region):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, code):
        _QuantLib.CustomRegion_swiginit(self, _QuantLib.new_CustomRegion(name, code))
    __swig_destroy__ = _QuantLib.delete_CustomRegion

# Register CustomRegion in _QuantLib:
_QuantLib.CustomRegion_swigregister(CustomRegion)

class InflationIndex(Index):
    thisown = 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.InflationIndex_familyName(self)

    def region(self):
        return _QuantLib.InflationIndex_region(self)

    def revised(self):
        return _QuantLib.InflationIndex_revised(self)

    def interpolated(self):
        return _QuantLib.InflationIndex_interpolated(self)

    def frequency(self):
        return _QuantLib.InflationIndex_frequency(self)

    def availabilityLag(self):
        return _QuantLib.InflationIndex_availabilityLag(self)

    def currency(self):
        return _QuantLib.InflationIndex_currency(self)
    __swig_destroy__ = _QuantLib.delete_InflationIndex

# Register InflationIndex in _QuantLib:
_QuantLib.InflationIndex_swigregister(InflationIndex)

class ZeroInflationIndex(InflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZeroInflationIndex_swiginit(self, _QuantLib.new_ZeroInflationIndex(*args))

    def zeroInflationTermStructure(self):
        return _QuantLib.ZeroInflationIndex_zeroInflationTermStructure(self)

    def clone(self, h):
        return _QuantLib.ZeroInflationIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationIndex

# Register ZeroInflationIndex in _QuantLib:
_QuantLib.ZeroInflationIndex_swigregister(ZeroInflationIndex)

class YoYInflationIndex(InflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YoYInflationIndex_swiginit(self, _QuantLib.new_YoYInflationIndex(*args))

    def ratio(self):
        return _QuantLib.YoYInflationIndex_ratio(self)

    def yoyInflationTermStructure(self):
        return _QuantLib.YoYInflationIndex_yoyInflationTermStructure(self)

    def clone(self, h):
        return _QuantLib.YoYInflationIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_YoYInflationIndex

# Register YoYInflationIndex in _QuantLib:
_QuantLib.YoYInflationIndex_swigregister(YoYInflationIndex)

class EUHICP(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EUHICP_swiginit(self, _QuantLib.new_EUHICP(*args))
    __swig_destroy__ = _QuantLib.delete_EUHICP

# Register EUHICP in _QuantLib:
_QuantLib.EUHICP_swigregister(EUHICP)

class EUHICPXT(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.EUHICPXT_swiginit(self, _QuantLib.new_EUHICPXT(*args))
    __swig_destroy__ = _QuantLib.delete_EUHICPXT

# Register EUHICPXT in _QuantLib:
_QuantLib.EUHICPXT_swigregister(EUHICPXT)

class FRHICP(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FRHICP_swiginit(self, _QuantLib.new_FRHICP(*args))
    __swig_destroy__ = _QuantLib.delete_FRHICP

# Register FRHICP in _QuantLib:
_QuantLib.FRHICP_swigregister(FRHICP)

class UKRPI(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.UKRPI_swiginit(self, _QuantLib.new_UKRPI(*args))
    __swig_destroy__ = _QuantLib.delete_UKRPI

# Register UKRPI in _QuantLib:
_QuantLib.UKRPI_swigregister(UKRPI)

class USCPI(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.USCPI_swiginit(self, _QuantLib.new_USCPI(*args))
    __swig_destroy__ = _QuantLib.delete_USCPI

# Register USCPI in _QuantLib:
_QuantLib.USCPI_swigregister(USCPI)

class ZACPI(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZACPI_swiginit(self, _QuantLib.new_ZACPI(*args))
    __swig_destroy__ = _QuantLib.delete_ZACPI

# Register ZACPI in _QuantLib:
_QuantLib.ZACPI_swigregister(ZACPI)

class YYEUHICP(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYEUHICP_swiginit(self, _QuantLib.new_YYEUHICP(*args))
    __swig_destroy__ = _QuantLib.delete_YYEUHICP

# Register YYEUHICP in _QuantLib:
_QuantLib.YYEUHICP_swigregister(YYEUHICP)

class YYEUHICPXT(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYEUHICPXT_swiginit(self, _QuantLib.new_YYEUHICPXT(*args))
    __swig_destroy__ = _QuantLib.delete_YYEUHICPXT

# Register YYEUHICPXT in _QuantLib:
_QuantLib.YYEUHICPXT_swigregister(YYEUHICPXT)

class YYEUHICPr(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYEUHICPr_swiginit(self, _QuantLib.new_YYEUHICPr(*args))
    __swig_destroy__ = _QuantLib.delete_YYEUHICPr

# Register YYEUHICPr in _QuantLib:
_QuantLib.YYEUHICPr_swigregister(YYEUHICPr)

class YYFRHICP(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYFRHICP_swiginit(self, _QuantLib.new_YYFRHICP(*args))
    __swig_destroy__ = _QuantLib.delete_YYFRHICP

# Register YYFRHICP in _QuantLib:
_QuantLib.YYFRHICP_swigregister(YYFRHICP)

class YYFRHICPr(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYFRHICPr_swiginit(self, _QuantLib.new_YYFRHICPr(*args))
    __swig_destroy__ = _QuantLib.delete_YYFRHICPr

# Register YYFRHICPr in _QuantLib:
_QuantLib.YYFRHICPr_swigregister(YYFRHICPr)

class YYUKRPI(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYUKRPI_swiginit(self, _QuantLib.new_YYUKRPI(*args))
    __swig_destroy__ = _QuantLib.delete_YYUKRPI

# Register YYUKRPI in _QuantLib:
_QuantLib.YYUKRPI_swigregister(YYUKRPI)

class YYUKRPIr(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYUKRPIr_swiginit(self, _QuantLib.new_YYUKRPIr(*args))
    __swig_destroy__ = _QuantLib.delete_YYUKRPIr

# Register YYUKRPIr in _QuantLib:
_QuantLib.YYUKRPIr_swigregister(YYUKRPIr)

class YYUSCPI(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYUSCPI_swiginit(self, _QuantLib.new_YYUSCPI(*args))
    __swig_destroy__ = _QuantLib.delete_YYUSCPI

# Register YYUSCPI in _QuantLib:
_QuantLib.YYUSCPI_swigregister(YYUSCPI)

class YYUSCPIr(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYUSCPIr_swiginit(self, _QuantLib.new_YYUSCPIr(*args))
    __swig_destroy__ = _QuantLib.delete_YYUSCPIr

# Register YYUSCPIr in _QuantLib:
_QuantLib.YYUSCPIr_swigregister(YYUSCPIr)

class YYZACPI(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYZACPI_swiginit(self, _QuantLib.new_YYZACPI(*args))
    __swig_destroy__ = _QuantLib.delete_YYZACPI

# Register YYZACPI in _QuantLib:
_QuantLib.YYZACPI_swigregister(YYZACPI)

class YYZACPIr(YoYInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YYZACPIr_swiginit(self, _QuantLib.new_YYZACPIr(*args))
    __swig_destroy__ = _QuantLib.delete_YYZACPIr

# Register YYZACPIr in _QuantLib:
_QuantLib.YYZACPIr_swigregister(YYZACPIr)

class AUCPI(ZeroInflationIndex):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.AUCPI_swiginit(self, _QuantLib.new_AUCPI(*args))
    __swig_destroy__ = _QuantLib.delete_AUCPI

# Register AUCPI in _QuantLib:
_QuantLib.AUCPI_swigregister(AUCPI)

class CPI(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AsIndex = _QuantLib.CPI_AsIndex
    Flat = _QuantLib.CPI_Flat
    Linear = _QuantLib.CPI_Linear

    def __init__(self):
        _QuantLib.CPI_swiginit(self, _QuantLib.new_CPI())
    __swig_destroy__ = _QuantLib.delete_CPI

# Register CPI in _QuantLib:
_QuantLib.CPI_swigregister(CPI)

class InflationCoupon(Coupon):
    thisown = 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 fixingDate(self):
        return _QuantLib.InflationCoupon_fixingDate(self)

    def fixingDays(self):
        return _QuantLib.InflationCoupon_fixingDays(self)

    def observationLag(self):
        return _QuantLib.InflationCoupon_observationLag(self)

    def indexFixing(self):
        return _QuantLib.InflationCoupon_indexFixing(self)

    def index(self):
        return _QuantLib.InflationCoupon_index(self)
    __swig_destroy__ = _QuantLib.delete_InflationCoupon

# Register InflationCoupon in _QuantLib:
_QuantLib.InflationCoupon_swigregister(InflationCoupon)


def as_inflation_coupon(cf):
    return _QuantLib.as_inflation_coupon(cf)
class CPICoupon(InflationCoupon):
    thisown = 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 fixedRate(self):
        return _QuantLib.CPICoupon_fixedRate(self)

    def spread(self):
        return _QuantLib.CPICoupon_spread(self)

    def adjustedFixing(self):
        return _QuantLib.CPICoupon_adjustedFixing(self)

    def baseCPI(self):
        return _QuantLib.CPICoupon_baseCPI(self)

    def observationInterpolation(self):
        return _QuantLib.CPICoupon_observationInterpolation(self)

    def cpiIndex(self):
        return _QuantLib.CPICoupon_cpiIndex(self)
    __swig_destroy__ = _QuantLib.delete_CPICoupon

# Register CPICoupon in _QuantLib:
_QuantLib.CPICoupon_swigregister(CPICoupon)


def as_cpi_coupon(cf):
    return _QuantLib.as_cpi_coupon(cf)
class ZeroHelper(Observable):
    thisown = 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 quote(self):
        return _QuantLib.ZeroHelper_quote(self)

    def latestDate(self):
        return _QuantLib.ZeroHelper_latestDate(self)

    def earliestDate(self):
        return _QuantLib.ZeroHelper_earliestDate(self)

    def maturityDate(self):
        return _QuantLib.ZeroHelper_maturityDate(self)

    def latestRelevantDate(self):
        return _QuantLib.ZeroHelper_latestRelevantDate(self)

    def pillarDate(self):
        return _QuantLib.ZeroHelper_pillarDate(self)

    def impliedQuote(self):
        return _QuantLib.ZeroHelper_impliedQuote(self)

    def quoteError(self):
        return _QuantLib.ZeroHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_ZeroHelper

# Register ZeroHelper in _QuantLib:
_QuantLib.ZeroHelper_swigregister(ZeroHelper)

class YoYHelper(Observable):
    thisown = 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 quote(self):
        return _QuantLib.YoYHelper_quote(self)

    def latestDate(self):
        return _QuantLib.YoYHelper_latestDate(self)

    def earliestDate(self):
        return _QuantLib.YoYHelper_earliestDate(self)

    def maturityDate(self):
        return _QuantLib.YoYHelper_maturityDate(self)

    def latestRelevantDate(self):
        return _QuantLib.YoYHelper_latestRelevantDate(self)

    def pillarDate(self):
        return _QuantLib.YoYHelper_pillarDate(self)

    def impliedQuote(self):
        return _QuantLib.YoYHelper_impliedQuote(self)

    def quoteError(self):
        return _QuantLib.YoYHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_YoYHelper

# Register YoYHelper in _QuantLib:
_QuantLib.YoYHelper_swigregister(YoYHelper)

class YoYOptionHelper(Observable):
    thisown = 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 quote(self):
        return _QuantLib.YoYOptionHelper_quote(self)

    def latestDate(self):
        return _QuantLib.YoYOptionHelper_latestDate(self)

    def earliestDate(self):
        return _QuantLib.YoYOptionHelper_earliestDate(self)

    def maturityDate(self):
        return _QuantLib.YoYOptionHelper_maturityDate(self)

    def latestRelevantDate(self):
        return _QuantLib.YoYOptionHelper_latestRelevantDate(self)

    def pillarDate(self):
        return _QuantLib.YoYOptionHelper_pillarDate(self)

    def impliedQuote(self):
        return _QuantLib.YoYOptionHelper_impliedQuote(self)

    def quoteError(self):
        return _QuantLib.YoYOptionHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_YoYOptionHelper

# Register YoYOptionHelper in _QuantLib:
_QuantLib.YoYOptionHelper_swigregister(YoYOptionHelper)

class ZeroHelperVector(object):
    thisown = 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.ZeroHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.ZeroHelperVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.ZeroHelperVector___bool__(self)

    def __len__(self):
        return _QuantLib.ZeroHelperVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.ZeroHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.ZeroHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.ZeroHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.ZeroHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.ZeroHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.ZeroHelperVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.ZeroHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.ZeroHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.ZeroHelperVector_empty(self)

    def size(self):
        return _QuantLib.ZeroHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.ZeroHelperVector_swap(self, v)

    def begin(self):
        return _QuantLib.ZeroHelperVector_begin(self)

    def end(self):
        return _QuantLib.ZeroHelperVector_end(self)

    def rbegin(self):
        return _QuantLib.ZeroHelperVector_rbegin(self)

    def rend(self):
        return _QuantLib.ZeroHelperVector_rend(self)

    def clear(self):
        return _QuantLib.ZeroHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.ZeroHelperVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.ZeroHelperVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.ZeroHelperVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.ZeroHelperVector_swiginit(self, _QuantLib.new_ZeroHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.ZeroHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.ZeroHelperVector_front(self)

    def back(self):
        return _QuantLib.ZeroHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.ZeroHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.ZeroHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.ZeroHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.ZeroHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.ZeroHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_ZeroHelperVector

# Register ZeroHelperVector in _QuantLib:
_QuantLib.ZeroHelperVector_swigregister(ZeroHelperVector)

class YoYHelperVector(object):
    thisown = 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.YoYHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.YoYHelperVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.YoYHelperVector___bool__(self)

    def __len__(self):
        return _QuantLib.YoYHelperVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.YoYHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.YoYHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.YoYHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.YoYHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.YoYHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.YoYHelperVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.YoYHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.YoYHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.YoYHelperVector_empty(self)

    def size(self):
        return _QuantLib.YoYHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.YoYHelperVector_swap(self, v)

    def begin(self):
        return _QuantLib.YoYHelperVector_begin(self)

    def end(self):
        return _QuantLib.YoYHelperVector_end(self)

    def rbegin(self):
        return _QuantLib.YoYHelperVector_rbegin(self)

    def rend(self):
        return _QuantLib.YoYHelperVector_rend(self)

    def clear(self):
        return _QuantLib.YoYHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.YoYHelperVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.YoYHelperVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.YoYHelperVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.YoYHelperVector_swiginit(self, _QuantLib.new_YoYHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.YoYHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.YoYHelperVector_front(self)

    def back(self):
        return _QuantLib.YoYHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.YoYHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.YoYHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.YoYHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.YoYHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.YoYHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_YoYHelperVector

# Register YoYHelperVector in _QuantLib:
_QuantLib.YoYHelperVector_swigregister(YoYHelperVector)

class YoYOptionHelperVector(object):
    thisown = 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.YoYOptionHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.YoYOptionHelperVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.YoYOptionHelperVector___bool__(self)

    def __len__(self):
        return _QuantLib.YoYOptionHelperVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.YoYOptionHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.YoYOptionHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.YoYOptionHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.YoYOptionHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.YoYOptionHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.YoYOptionHelperVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.YoYOptionHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.YoYOptionHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.YoYOptionHelperVector_empty(self)

    def size(self):
        return _QuantLib.YoYOptionHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.YoYOptionHelperVector_swap(self, v)

    def begin(self):
        return _QuantLib.YoYOptionHelperVector_begin(self)

    def end(self):
        return _QuantLib.YoYOptionHelperVector_end(self)

    def rbegin(self):
        return _QuantLib.YoYOptionHelperVector_rbegin(self)

    def rend(self):
        return _QuantLib.YoYOptionHelperVector_rend(self)

    def clear(self):
        return _QuantLib.YoYOptionHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.YoYOptionHelperVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.YoYOptionHelperVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.YoYOptionHelperVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.YoYOptionHelperVector_swiginit(self, _QuantLib.new_YoYOptionHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.YoYOptionHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.YoYOptionHelperVector_front(self)

    def back(self):
        return _QuantLib.YoYOptionHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.YoYOptionHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.YoYOptionHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.YoYOptionHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.YoYOptionHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.YoYOptionHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_YoYOptionHelperVector

# Register YoYOptionHelperVector in _QuantLib:
_QuantLib.YoYOptionHelperVector_swigregister(YoYOptionHelperVector)

class ZeroCouponInflationSwapHelper(ZeroHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZeroCouponInflationSwapHelper_swiginit(self, _QuantLib.new_ZeroCouponInflationSwapHelper(*args))
    __swig_destroy__ = _QuantLib.delete_ZeroCouponInflationSwapHelper

# Register ZeroCouponInflationSwapHelper in _QuantLib:
_QuantLib.ZeroCouponInflationSwapHelper_swigregister(ZeroCouponInflationSwapHelper)

class YearOnYearInflationSwapHelper(YoYHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YearOnYearInflationSwapHelper_swiginit(self, _QuantLib.new_YearOnYearInflationSwapHelper(*args))
    __swig_destroy__ = _QuantLib.delete_YearOnYearInflationSwapHelper

# Register YearOnYearInflationSwapHelper in _QuantLib:
_QuantLib.YearOnYearInflationSwapHelper_swigregister(YearOnYearInflationSwapHelper)

class PiecewiseZeroInflation(ZeroInflationTermStructure):
    thisown = 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):
        _QuantLib.PiecewiseZeroInflation_swiginit(self, _QuantLib.new_PiecewiseZeroInflation(*args, **kwargs))

    def dates(self):
        return _QuantLib.PiecewiseZeroInflation_dates(self)

    def times(self):
        return _QuantLib.PiecewiseZeroInflation_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseZeroInflation_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseZeroInflation

# Register PiecewiseZeroInflation in _QuantLib:
_QuantLib.PiecewiseZeroInflation_swigregister(PiecewiseZeroInflation)

class PiecewiseYoYInflation(YoYInflationTermStructure):
    thisown = 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):
        _QuantLib.PiecewiseYoYInflation_swiginit(self, _QuantLib.new_PiecewiseYoYInflation(*args, **kwargs))

    def dates(self):
        return _QuantLib.PiecewiseYoYInflation_dates(self)

    def times(self):
        return _QuantLib.PiecewiseYoYInflation_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseYoYInflation_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseYoYInflation

# Register PiecewiseYoYInflation in _QuantLib:
_QuantLib.PiecewiseYoYInflation_swigregister(PiecewiseYoYInflation)


def inflationBaseDate(referenceDate, observationLag, frequency, indexIsInterpolated):
    return _QuantLib.inflationBaseDate(referenceDate, observationLag, frequency, indexIsInterpolated)

def yoyInflationLeg(*args, **kwargs):
    return _QuantLib.yoyInflationLeg(*args, **kwargs)
class ZeroCouponInflationSwap(Swap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Receiver = _QuantLib.ZeroCouponInflationSwap_Receiver
    Payer = _QuantLib.ZeroCouponInflationSwap_Payer

    def __init__(self, *args):
        _QuantLib.ZeroCouponInflationSwap_swiginit(self, _QuantLib.new_ZeroCouponInflationSwap(*args))

    def fairRate(self):
        return _QuantLib.ZeroCouponInflationSwap_fairRate(self)

    def fixedLegNPV(self):
        return _QuantLib.ZeroCouponInflationSwap_fixedLegNPV(self)

    def inflationLegNPV(self):
        return _QuantLib.ZeroCouponInflationSwap_inflationLegNPV(self)

    def fixedLeg(self):
        return _QuantLib.ZeroCouponInflationSwap_fixedLeg(self)

    def inflationLeg(self):
        return _QuantLib.ZeroCouponInflationSwap_inflationLeg(self)

    def type(self):
        return _QuantLib.ZeroCouponInflationSwap_type(self)
    __swig_destroy__ = _QuantLib.delete_ZeroCouponInflationSwap

# Register ZeroCouponInflationSwap in _QuantLib:
_QuantLib.ZeroCouponInflationSwap_swigregister(ZeroCouponInflationSwap)

class YearOnYearInflationSwap(Swap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Receiver = _QuantLib.YearOnYearInflationSwap_Receiver
    Payer = _QuantLib.YearOnYearInflationSwap_Payer

    def __init__(self, type, nominal, fixedSchedule, fixedRate, fixedDayCounter, yoySchedule, index, lag, spread, yoyDayCounter, paymentCalendar, paymentConvention=Following):
        _QuantLib.YearOnYearInflationSwap_swiginit(self, _QuantLib.new_YearOnYearInflationSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCounter, yoySchedule, index, lag, spread, yoyDayCounter, paymentCalendar, paymentConvention))

    def fairRate(self):
        return _QuantLib.YearOnYearInflationSwap_fairRate(self)

    def fixedLegNPV(self):
        return _QuantLib.YearOnYearInflationSwap_fixedLegNPV(self)

    def yoyLegNPV(self):
        return _QuantLib.YearOnYearInflationSwap_yoyLegNPV(self)

    def fairSpread(self):
        return _QuantLib.YearOnYearInflationSwap_fairSpread(self)

    def fixedLeg(self):
        return _QuantLib.YearOnYearInflationSwap_fixedLeg(self)

    def yoyLeg(self):
        return _QuantLib.YearOnYearInflationSwap_yoyLeg(self)
    __swig_destroy__ = _QuantLib.delete_YearOnYearInflationSwap

# Register YearOnYearInflationSwap in _QuantLib:
_QuantLib.YearOnYearInflationSwap_swigregister(YearOnYearInflationSwap)

class CPISwap(Swap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Receiver = _QuantLib.CPISwap_Receiver
    Payer = _QuantLib.CPISwap_Payer

    def __init__(self, *args):
        _QuantLib.CPISwap_swiginit(self, _QuantLib.new_CPISwap(*args))

    def fairRate(self):
        return _QuantLib.CPISwap_fairRate(self)

    def floatLegNPV(self):
        return _QuantLib.CPISwap_floatLegNPV(self)

    def fairSpread(self):
        return _QuantLib.CPISwap_fairSpread(self)

    def fixedLegNPV(self):
        return _QuantLib.CPISwap_fixedLegNPV(self)

    def cpiLeg(self):
        return _QuantLib.CPISwap_cpiLeg(self)

    def floatLeg(self):
        return _QuantLib.CPISwap_floatLeg(self)
    __swig_destroy__ = _QuantLib.delete_CPISwap

# Register CPISwap in _QuantLib:
_QuantLib.CPISwap_swigregister(CPISwap)

class YoYInflationCapFloor(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Cap = _QuantLib.YoYInflationCapFloor_Cap
    Floor = _QuantLib.YoYInflationCapFloor_Floor
    Collar = _QuantLib.YoYInflationCapFloor_Collar

    def __init__(self, type, yoyLeg, strikes):
        _QuantLib.YoYInflationCapFloor_swiginit(self, _QuantLib.new_YoYInflationCapFloor(type, yoyLeg, strikes))

    def impliedVolatility(self, price, curve, guess, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0):
        return _QuantLib.YoYInflationCapFloor_impliedVolatility(self, price, curve, guess, accuracy, maxEvaluations, minVol, maxVol)

    def optionletPrices(self):
        return _QuantLib.YoYInflationCapFloor_optionletPrices(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationCapFloor

# Register YoYInflationCapFloor in _QuantLib:
_QuantLib.YoYInflationCapFloor_swigregister(YoYInflationCapFloor)

class YoYInflationCap(YoYInflationCapFloor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leg, capRates):
        _QuantLib.YoYInflationCap_swiginit(self, _QuantLib.new_YoYInflationCap(leg, capRates))
    __swig_destroy__ = _QuantLib.delete_YoYInflationCap

# Register YoYInflationCap in _QuantLib:
_QuantLib.YoYInflationCap_swigregister(YoYInflationCap)

class YoYInflationFloor(YoYInflationCapFloor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leg, floorRates):
        _QuantLib.YoYInflationFloor_swiginit(self, _QuantLib.new_YoYInflationFloor(leg, floorRates))
    __swig_destroy__ = _QuantLib.delete_YoYInflationFloor

# Register YoYInflationFloor in _QuantLib:
_QuantLib.YoYInflationFloor_swigregister(YoYInflationFloor)

class YoYInflationCollar(YoYInflationCapFloor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leg, capRates, floorRates):
        _QuantLib.YoYInflationCollar_swiginit(self, _QuantLib.new_YoYInflationCollar(leg, capRates, floorRates))
    __swig_destroy__ = _QuantLib.delete_YoYInflationCollar

# Register YoYInflationCollar in _QuantLib:
_QuantLib.YoYInflationCollar_swigregister(YoYInflationCollar)

class ZeroInflationCurve(ZeroInflationTermStructure):
    thisown = 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):
        _QuantLib.ZeroInflationCurve_swiginit(self, _QuantLib.new_ZeroInflationCurve(*args, **kwargs))

    def dates(self):
        return _QuantLib.ZeroInflationCurve_dates(self)

    def times(self):
        return _QuantLib.ZeroInflationCurve_times(self)

    def data(self):
        return _QuantLib.ZeroInflationCurve_data(self)

    def rates(self):
        return _QuantLib.ZeroInflationCurve_rates(self)

    def nodes(self):
        return _QuantLib.ZeroInflationCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ZeroInflationCurve

# Register ZeroInflationCurve in _QuantLib:
_QuantLib.ZeroInflationCurve_swigregister(ZeroInflationCurve)

class YoYInflationCurve(YoYInflationTermStructure):
    thisown = 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):
        _QuantLib.YoYInflationCurve_swiginit(self, _QuantLib.new_YoYInflationCurve(*args, **kwargs))

    def dates(self):
        return _QuantLib.YoYInflationCurve_dates(self)

    def times(self):
        return _QuantLib.YoYInflationCurve_times(self)

    def data(self):
        return _QuantLib.YoYInflationCurve_data(self)

    def rates(self):
        return _QuantLib.YoYInflationCurve_rates(self)

    def nodes(self):
        return _QuantLib.YoYInflationCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_YoYInflationCurve

# Register YoYInflationCurve in _QuantLib:
_QuantLib.YoYInflationCurve_swigregister(YoYInflationCurve)

class YoYCapFloorTermPriceSurface(InflationTermStructure):
    thisown = 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 atmYoYSwapTimeRates(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates(self)

    def atmYoYSwapDateRates(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYSwapDateRates(self)

    def YoYTS(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_YoYTS(self)

    def yoyIndex(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_yoyIndex(self)

    def businessDayConvention(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_businessDayConvention(self)

    def fixingDays(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_fixingDays(self)

    def price(self, *args):
        return _QuantLib.YoYCapFloorTermPriceSurface_price(self, *args)

    def capPrice(self, *args):
        return _QuantLib.YoYCapFloorTermPriceSurface_capPrice(self, *args)

    def floorPrice(self, *args):
        return _QuantLib.YoYCapFloorTermPriceSurface_floorPrice(self, *args)

    def atmYoYSwapRate(self, *args):
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYSwapRate(self, *args)

    def atmYoYRate(self, *args):
        return _QuantLib.YoYCapFloorTermPriceSurface_atmYoYRate(self, *args)

    def strikes(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_strikes(self)

    def capStrikes(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_capStrikes(self)

    def floorStrikes(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_floorStrikes(self)

    def maturities(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_maturities(self)

    def minStrike(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_minStrike(self)

    def maxStrike(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_maxStrike(self)

    def minMaturity(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_minMaturity(self)

    def maxMaturity(self):
        return _QuantLib.YoYCapFloorTermPriceSurface_maxMaturity(self)

    def yoyOptionDateFromTenor(self, p):
        return _QuantLib.YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor(self, p)
    __swig_destroy__ = _QuantLib.delete_YoYCapFloorTermPriceSurface

# Register YoYCapFloorTermPriceSurface in _QuantLib:
_QuantLib.YoYCapFloorTermPriceSurface_swigregister(YoYCapFloorTermPriceSurface)

class YoYInflationCapFloorTermPriceSurface(YoYCapFloorTermPriceSurface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.YoYInflationCapFloorTermPriceSurface_swiginit(self, _QuantLib.new_YoYInflationCapFloorTermPriceSurface(*args))
    __swig_destroy__ = _QuantLib.delete_YoYInflationCapFloorTermPriceSurface

# Register YoYInflationCapFloorTermPriceSurface in _QuantLib:
_QuantLib.YoYInflationCapFloorTermPriceSurface_swigregister(YoYInflationCapFloorTermPriceSurface)

class YoYInflationBlackCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, vol, nominalTermStructure):
        _QuantLib.YoYInflationBlackCapFloorEngine_swiginit(self, _QuantLib.new_YoYInflationBlackCapFloorEngine(arg2, vol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_YoYInflationBlackCapFloorEngine

# Register YoYInflationBlackCapFloorEngine in _QuantLib:
_QuantLib.YoYInflationBlackCapFloorEngine_swigregister(YoYInflationBlackCapFloorEngine)

class YoYInflationUnitDisplacedBlackCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, vol, nominalTermStructure):
        _QuantLib.YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit(self, _QuantLib.new_YoYInflationUnitDisplacedBlackCapFloorEngine(arg2, vol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_YoYInflationUnitDisplacedBlackCapFloorEngine

# Register YoYInflationUnitDisplacedBlackCapFloorEngine in _QuantLib:
_QuantLib.YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister(YoYInflationUnitDisplacedBlackCapFloorEngine)

class YoYInflationBachelierCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, vol, nominalTermStructure):
        _QuantLib.YoYInflationBachelierCapFloorEngine_swiginit(self, _QuantLib.new_YoYInflationBachelierCapFloorEngine(arg2, vol, nominalTermStructure))
    __swig_destroy__ = _QuantLib.delete_YoYInflationBachelierCapFloorEngine

# Register YoYInflationBachelierCapFloorEngine in _QuantLib:
_QuantLib.YoYInflationBachelierCapFloorEngine_swigregister(YoYInflationBachelierCapFloorEngine)

class YoYOptionletHelper(YoYOptionHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, price, notional, capFloorType, lag, yoyDayCounter, paymentCalendar, fixingDays, index, strike, n, pricer):
        _QuantLib.YoYOptionletHelper_swiginit(self, _QuantLib.new_YoYOptionletHelper(price, notional, capFloorType, lag, yoyDayCounter, paymentCalendar, fixingDays, index, strike, n, pricer))
    __swig_destroy__ = _QuantLib.delete_YoYOptionletHelper

# Register YoYOptionletHelper in _QuantLib:
_QuantLib.YoYOptionletHelper_swigregister(YoYOptionletHelper)

class YoYOptionletStripper(object):
    thisown = 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 initialize(self, surf, pricer, slope):
        return _QuantLib.YoYOptionletStripper_initialize(self, surf, pricer, slope)

    def maxStrike(self):
        return _QuantLib.YoYOptionletStripper_maxStrike(self)

    def strikes(self):
        return _QuantLib.YoYOptionletStripper_strikes(self)

    def slice(self, d):
        return _QuantLib.YoYOptionletStripper_slice(self, d)
    __swig_destroy__ = _QuantLib.delete_YoYOptionletStripper

# Register YoYOptionletStripper in _QuantLib:
_QuantLib.YoYOptionletStripper_swigregister(YoYOptionletStripper)

class InterpolatedYoYInflationOptionletStripper(YoYOptionletStripper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.InterpolatedYoYInflationOptionletStripper_swiginit(self, _QuantLib.new_InterpolatedYoYInflationOptionletStripper())
    __swig_destroy__ = _QuantLib.delete_InterpolatedYoYInflationOptionletStripper

# Register InterpolatedYoYInflationOptionletStripper in _QuantLib:
_QuantLib.InterpolatedYoYInflationOptionletStripper_swigregister(InterpolatedYoYInflationOptionletStripper)

class InterpolatedYoYInflationOptionletVolatilityCurve(YoYOptionletVolatilitySurface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InterpolatedYoYInflationOptionletVolatilityCurve_swiginit(self, _QuantLib.new_InterpolatedYoYInflationOptionletVolatilityCurve(*args))
    __swig_destroy__ = _QuantLib.delete_InterpolatedYoYInflationOptionletVolatilityCurve

# Register InterpolatedYoYInflationOptionletVolatilityCurve in _QuantLib:
_QuantLib.InterpolatedYoYInflationOptionletVolatilityCurve_swigregister(InterpolatedYoYInflationOptionletVolatilityCurve)

class KInterpolatedYoYInflationOptionletVolatilitySurface(YoYOptionletVolatilitySurface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit(self, _QuantLib.new_KInterpolatedYoYInflationOptionletVolatilitySurface(*args))

    def Dslice(self, d):
        return _QuantLib.KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice(self, d)
    __swig_destroy__ = _QuantLib.delete_KInterpolatedYoYInflationOptionletVolatilitySurface

# Register KInterpolatedYoYInflationOptionletVolatilitySurface in _QuantLib:
_QuantLib.KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister(KInterpolatedYoYInflationOptionletVolatilitySurface)

class ShortRateModel(CalibratedModel):
    thisown = 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_ShortRateModel

# Register ShortRateModel in _QuantLib:
_QuantLib.ShortRateModel_swigregister(ShortRateModel)

class ShortRateModelHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ShortRateModelHandle_swiginit(self, _QuantLib.new_ShortRateModelHandle(*args))

    def __deref__(self):
        return _QuantLib.ShortRateModelHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.ShortRateModelHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.ShortRateModelHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.ShortRateModelHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.ShortRateModelHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_ShortRateModelHandle

    def params(self):
        return _QuantLib.ShortRateModelHandle_params(self)

    def calibrate(self, *args):
        return _QuantLib.ShortRateModelHandle_calibrate(self, *args)

    def setParams(self, params):
        return _QuantLib.ShortRateModelHandle_setParams(self, params)

    def value(self, params, arg3):
        return _QuantLib.ShortRateModelHandle_value(self, params, arg3)

    def constraint(self):
        return _QuantLib.ShortRateModelHandle_constraint(self)

    def endCriteria(self):
        return _QuantLib.ShortRateModelHandle_endCriteria(self)

    def problemValues(self):
        return _QuantLib.ShortRateModelHandle_problemValues(self)

    def functionEvaluation(self):
        return _QuantLib.ShortRateModelHandle_functionEvaluation(self)

# Register ShortRateModelHandle in _QuantLib:
_QuantLib.ShortRateModelHandle_swigregister(ShortRateModelHandle)

class RelinkableShortRateModelHandle(ShortRateModelHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableShortRateModelHandle_swiginit(self, _QuantLib.new_RelinkableShortRateModelHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableShortRateModelHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableShortRateModelHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableShortRateModelHandle

# Register RelinkableShortRateModelHandle in _QuantLib:
_QuantLib.RelinkableShortRateModelHandle_swigregister(RelinkableShortRateModelHandle)

class OneFactorAffineModel(ShortRateModel):
    thisown = 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 discountBond(self, *args):
        return _QuantLib.OneFactorAffineModel_discountBond(self, *args)

    def discount(self, t):
        return _QuantLib.OneFactorAffineModel_discount(self, t)
    __swig_destroy__ = _QuantLib.delete_OneFactorAffineModel

# Register OneFactorAffineModel in _QuantLib:
_QuantLib.OneFactorAffineModel_swigregister(OneFactorAffineModel)

class Vasicek(OneFactorAffineModel):
    thisown = 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_parameter=0.0):
        _QuantLib.Vasicek_swiginit(self, _QuantLib.new_Vasicek(r0, a, b, sigma, lambda_parameter))
    __swig_destroy__ = _QuantLib.delete_Vasicek

# Register Vasicek in _QuantLib:
_QuantLib.Vasicek_swigregister(Vasicek)

class HullWhite(Vasicek):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, termStructure, a=0.1, sigma=0.01):
        _QuantLib.HullWhite_swiginit(self, _QuantLib.new_HullWhite(termStructure, a, sigma))

    @staticmethod
    def convexityBias(futurePrice, t, T, sigma, a):
        return _QuantLib.HullWhite_convexityBias(futurePrice, t, T, sigma, a)

    def termStructure(self):
        return _QuantLib.HullWhite_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_HullWhite

# Register HullWhite in _QuantLib:
_QuantLib.HullWhite_swigregister(HullWhite)

def HullWhite_convexityBias(futurePrice, t, T, sigma, a):
    return _QuantLib.HullWhite_convexityBias(futurePrice, t, T, sigma, a)

class BlackKarasinski(ShortRateModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, termStructure, a=0.1, sigma=0.1):
        _QuantLib.BlackKarasinski_swiginit(self, _QuantLib.new_BlackKarasinski(termStructure, a, sigma))

    def termStructure(self):
        return _QuantLib.BlackKarasinski_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_BlackKarasinski

# Register BlackKarasinski in _QuantLib:
_QuantLib.BlackKarasinski_swigregister(BlackKarasinski)

class CoxIngersollRoss(ShortRateModel):
    thisown = 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.01, theta=0.1, k=0.1, sigma=0.1):
        _QuantLib.CoxIngersollRoss_swiginit(self, _QuantLib.new_CoxIngersollRoss(r0, theta, k, sigma))

    def discount(self, t):
        return _QuantLib.CoxIngersollRoss_discount(self, t)
    __swig_destroy__ = _QuantLib.delete_CoxIngersollRoss

# Register CoxIngersollRoss in _QuantLib:
_QuantLib.CoxIngersollRoss_swigregister(CoxIngersollRoss)

class ExtendedCoxIngersollRoss(ShortRateModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, termStructure, theta=0.1, k=0.1, sigma=0.1, x0=0.05):
        _QuantLib.ExtendedCoxIngersollRoss_swiginit(self, _QuantLib.new_ExtendedCoxIngersollRoss(termStructure, theta, k, sigma, x0))

    def discount(self, t):
        return _QuantLib.ExtendedCoxIngersollRoss_discount(self, t)
    __swig_destroy__ = _QuantLib.delete_ExtendedCoxIngersollRoss

# Register ExtendedCoxIngersollRoss in _QuantLib:
_QuantLib.ExtendedCoxIngersollRoss_swigregister(ExtendedCoxIngersollRoss)

class G2(ShortRateModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, termStructure, a=0.1, sigma=0.01, b=0.1, eta=0.01, rho=-0.75):
        _QuantLib.G2_swiginit(self, _QuantLib.new_G2(termStructure, a, sigma, b, eta, rho))

    def termStructure(self):
        return _QuantLib.G2_termStructure(self)
    __swig_destroy__ = _QuantLib.delete_G2

# Register G2 in _QuantLib:
_QuantLib.G2_swigregister(G2)

class JamshidianSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.JamshidianSwaptionEngine_swiginit(self, _QuantLib.new_JamshidianSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_JamshidianSwaptionEngine

# Register JamshidianSwaptionEngine in _QuantLib:
_QuantLib.JamshidianSwaptionEngine_swigregister(JamshidianSwaptionEngine)

class TreeSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.TreeSwaptionEngine_swiginit(self, _QuantLib.new_TreeSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_TreeSwaptionEngine

# Register TreeSwaptionEngine in _QuantLib:
_QuantLib.TreeSwaptionEngine_swigregister(TreeSwaptionEngine)

class AnalyticCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.AnalyticCapFloorEngine_swiginit(self, _QuantLib.new_AnalyticCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_AnalyticCapFloorEngine

# Register AnalyticCapFloorEngine in _QuantLib:
_QuantLib.AnalyticCapFloorEngine_swigregister(AnalyticCapFloorEngine)

class TreeCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.TreeCapFloorEngine_swiginit(self, _QuantLib.new_TreeCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_TreeCapFloorEngine

# Register TreeCapFloorEngine in _QuantLib:
_QuantLib.TreeCapFloorEngine_swigregister(TreeCapFloorEngine)

class G2SwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, model, range, intervals):
        _QuantLib.G2SwaptionEngine_swiginit(self, _QuantLib.new_G2SwaptionEngine(model, range, intervals))
    __swig_destroy__ = _QuantLib.delete_G2SwaptionEngine

# Register G2SwaptionEngine in _QuantLib:
_QuantLib.G2SwaptionEngine_swigregister(G2SwaptionEngine)

class FdG2SwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdG2SwaptionEngine_swiginit(self, _QuantLib.new_FdG2SwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdG2SwaptionEngine

# Register FdG2SwaptionEngine in _QuantLib:
_QuantLib.FdG2SwaptionEngine_swigregister(FdG2SwaptionEngine)

class FdHullWhiteSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdHullWhiteSwaptionEngine_swiginit(self, _QuantLib.new_FdHullWhiteSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_FdHullWhiteSwaptionEngine

# Register FdHullWhiteSwaptionEngine in _QuantLib:
_QuantLib.FdHullWhiteSwaptionEngine_swigregister(FdHullWhiteSwaptionEngine)

class AnalyticBSMHullWhiteEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, equityShortRateCorrelation, arg3, arg4):
        _QuantLib.AnalyticBSMHullWhiteEngine_swiginit(self, _QuantLib.new_AnalyticBSMHullWhiteEngine(equityShortRateCorrelation, arg3, arg4))
    __swig_destroy__ = _QuantLib.delete_AnalyticBSMHullWhiteEngine

# Register AnalyticBSMHullWhiteEngine in _QuantLib:
_QuantLib.AnalyticBSMHullWhiteEngine_swigregister(AnalyticBSMHullWhiteEngine)

class Bond(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Bond_swiginit(self, _QuantLib.new_Bond(*args))

    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, *args):
        return _QuantLib.Bond_settlementDate(self, *args)

    def startDate(self):
        return _QuantLib.Bond_startDate(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

# Register Bond in _QuantLib:
_QuantLib.Bond_swigregister(Bond)


def cleanPriceFromZSpread(*args):
    return _QuantLib.cleanPriceFromZSpread(*args)
class ZeroCouponBond(Bond):
    thisown = 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):
        _QuantLib.ZeroCouponBond_swiginit(self, _QuantLib.new_ZeroCouponBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_ZeroCouponBond

# Register ZeroCouponBond in _QuantLib:
_QuantLib.ZeroCouponBond_swigregister(ZeroCouponBond)

class FixedRateBond(Bond):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FixedRateBond_swiginit(self, _QuantLib.new_FixedRateBond(*args))

    @staticmethod
    def from_rates(*args, **kwargs):
        return _QuantLib.FixedRateBond_from_rates(*args, **kwargs)

    @staticmethod
    def from_interest_rates(*args, **kwargs):
        return _QuantLib.FixedRateBond_from_interest_rates(*args, **kwargs)

    @staticmethod
    def from_date_info(*args, **kwargs):
        return _QuantLib.FixedRateBond_from_date_info(*args, **kwargs)

    def frequency(self):
        return _QuantLib.FixedRateBond_frequency(self)

    def dayCounter(self):
        return _QuantLib.FixedRateBond_dayCounter(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBond

# Register FixedRateBond in _QuantLib:
_QuantLib.FixedRateBond_swigregister(FixedRateBond)

def FixedRateBond_from_rates(*args, **kwargs):
    return _QuantLib.FixedRateBond_from_rates(*args, **kwargs)

def FixedRateBond_from_interest_rates(*args, **kwargs):
    return _QuantLib.FixedRateBond_from_interest_rates(*args, **kwargs)

def FixedRateBond_from_date_info(*args, **kwargs):
    return _QuantLib.FixedRateBond_from_date_info(*args, **kwargs)

class AmortizingFixedRateBond(Bond):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.AmortizingFixedRateBond_swiginit(self, _QuantLib.new_AmortizingFixedRateBond(*args))

    def frequency(self):
        return _QuantLib.AmortizingFixedRateBond_frequency(self)

    def dayCounter(self):
        return _QuantLib.AmortizingFixedRateBond_dayCounter(self)
    __swig_destroy__ = _QuantLib.delete_AmortizingFixedRateBond

# Register AmortizingFixedRateBond in _QuantLib:
_QuantLib.AmortizingFixedRateBond_swigregister(AmortizingFixedRateBond)

class AmortizingFloatingRateBond(Bond):
    thisown = 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):
        _QuantLib.AmortizingFloatingRateBond_swiginit(self, _QuantLib.new_AmortizingFloatingRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_AmortizingFloatingRateBond

# Register AmortizingFloatingRateBond in _QuantLib:
_QuantLib.AmortizingFloatingRateBond_swigregister(AmortizingFloatingRateBond)

class FloatingRateBond(Bond):
    thisown = 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):
        _QuantLib.FloatingRateBond_swiginit(self, _QuantLib.new_FloatingRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_FloatingRateBond

# Register FloatingRateBond in _QuantLib:
_QuantLib.FloatingRateBond_swigregister(FloatingRateBond)

class CmsRateBond(Bond):
    thisown = 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):
        _QuantLib.CmsRateBond_swiginit(self, _QuantLib.new_CmsRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CmsRateBond

# Register CmsRateBond in _QuantLib:
_QuantLib.CmsRateBond_swigregister(CmsRateBond)

class DiscountingBondEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, discountCurve):
        _QuantLib.DiscountingBondEngine_swiginit(self, _QuantLib.new_DiscountingBondEngine(discountCurve))
    __swig_destroy__ = _QuantLib.delete_DiscountingBondEngine

# Register DiscountingBondEngine in _QuantLib:
_QuantLib.DiscountingBondEngine_swigregister(DiscountingBondEngine)

class CallableBond(Bond):
    thisown = 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 callability(self):
        return _QuantLib.CallableBond_callability(self)

    def impliedVolatility(self, targetValue, discountCurve, accuracy, maxEvaluations, minVol, maxVol):
        return _QuantLib.CallableBond_impliedVolatility(self, targetValue, discountCurve, accuracy, maxEvaluations, minVol, maxVol)

    def OAS(self, *args):
        return _QuantLib.CallableBond_OAS(self, *args)

    def cleanPriceOAS(self, *args):
        return _QuantLib.CallableBond_cleanPriceOAS(self, *args)

    def effectiveDuration(self, oas, engineTS, dayCounter, compounding, frequency, bump=2e-4):
        return _QuantLib.CallableBond_effectiveDuration(self, oas, engineTS, dayCounter, compounding, frequency, bump)

    def effectiveConvexity(self, oas, engineTS, dayCounter, compounding, frequency, bump=2e-4):
        return _QuantLib.CallableBond_effectiveConvexity(self, oas, engineTS, dayCounter, compounding, frequency, bump)
    __swig_destroy__ = _QuantLib.delete_CallableBond

# Register CallableBond in _QuantLib:
_QuantLib.CallableBond_swigregister(CallableBond)

class CallableFixedRateBond(CallableBond):
    thisown = 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):
        _QuantLib.CallableFixedRateBond_swiginit(self, _QuantLib.new_CallableFixedRateBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CallableFixedRateBond

# Register CallableFixedRateBond in _QuantLib:
_QuantLib.CallableFixedRateBond_swigregister(CallableFixedRateBond)

class CallableZeroCouponBond(CallableBond):
    thisown = 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):
        _QuantLib.CallableZeroCouponBond_swiginit(self, _QuantLib.new_CallableZeroCouponBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CallableZeroCouponBond

# Register CallableZeroCouponBond in _QuantLib:
_QuantLib.CallableZeroCouponBond_swigregister(CallableZeroCouponBond)

class TreeCallableFixedRateBondEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.TreeCallableFixedRateBondEngine_swiginit(self, _QuantLib.new_TreeCallableFixedRateBondEngine(*args))
    __swig_destroy__ = _QuantLib.delete_TreeCallableFixedRateBondEngine

# Register TreeCallableFixedRateBondEngine in _QuantLib:
_QuantLib.TreeCallableFixedRateBondEngine_swigregister(TreeCallableFixedRateBondEngine)

class BlackCallableFixedRateBondEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, fwdYieldVol, discountCurve):
        _QuantLib.BlackCallableFixedRateBondEngine_swiginit(self, _QuantLib.new_BlackCallableFixedRateBondEngine(fwdYieldVol, discountCurve))
    __swig_destroy__ = _QuantLib.delete_BlackCallableFixedRateBondEngine

# Register BlackCallableFixedRateBondEngine in _QuantLib:
_QuantLib.BlackCallableFixedRateBondEngine_swigregister(BlackCallableFixedRateBondEngine)

class CPIBond(Bond):
    thisown = 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):
        _QuantLib.CPIBond_swiginit(self, _QuantLib.new_CPIBond(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_CPIBond

# Register CPIBond in _QuantLib:
_QuantLib.CPIBond_swigregister(CPIBond)

class BondFunctions(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def startDate(bond):
        return _QuantLib.BondFunctions_startDate(bond)

    @staticmethod
    def maturityDate(bond):
        return _QuantLib.BondFunctions_maturityDate(bond)

    @staticmethod
    def isTradable(*args):
        return _QuantLib.BondFunctions_isTradable(*args)

    @staticmethod
    def previousCashFlowDate(*args):
        return _QuantLib.BondFunctions_previousCashFlowDate(*args)

    @staticmethod
    def nextCashFlowDate(*args):
        return _QuantLib.BondFunctions_nextCashFlowDate(*args)

    @staticmethod
    def previousCashFlowAmount(*args):
        return _QuantLib.BondFunctions_previousCashFlowAmount(*args)

    @staticmethod
    def nextCashFlowAmount(*args):
        return _QuantLib.BondFunctions_nextCashFlowAmount(*args)

    @staticmethod
    def previousCouponRate(*args):
        return _QuantLib.BondFunctions_previousCouponRate(*args)

    @staticmethod
    def nextCouponRate(*args):
        return _QuantLib.BondFunctions_nextCouponRate(*args)

    @staticmethod
    def accrualStartDate(*args):
        return _QuantLib.BondFunctions_accrualStartDate(*args)

    @staticmethod
    def accrualEndDate(*args):
        return _QuantLib.BondFunctions_accrualEndDate(*args)

    @staticmethod
    def accrualPeriod(*args):
        return _QuantLib.BondFunctions_accrualPeriod(*args)

    @staticmethod
    def accrualDays(*args):
        return _QuantLib.BondFunctions_accrualDays(*args)

    @staticmethod
    def accruedPeriod(*args):
        return _QuantLib.BondFunctions_accruedPeriod(*args)

    @staticmethod
    def accruedDays(*args):
        return _QuantLib.BondFunctions_accruedDays(*args)

    @staticmethod
    def accruedAmount(*args):
        return _QuantLib.BondFunctions_accruedAmount(*args)

    @staticmethod
    def atmRate(*args):
        return _QuantLib.BondFunctions_atmRate(*args)

    @staticmethod
    def cleanPrice(*args):
        return _QuantLib.BondFunctions_cleanPrice(*args)

    @staticmethod
    def bps(*args):
        return _QuantLib.BondFunctions_bps(*args)

    @staticmethod
    def bondYield(*args):
        return _QuantLib.BondFunctions_bondYield(*args)

    @staticmethod
    def duration(*args):
        return _QuantLib.BondFunctions_duration(*args)

    @staticmethod
    def convexity(*args):
        return _QuantLib.BondFunctions_convexity(*args)

    @staticmethod
    def basisPointValue(*args):
        return _QuantLib.BondFunctions_basisPointValue(*args)

    @staticmethod
    def yieldValueBasisPoint(*args):
        return _QuantLib.BondFunctions_yieldValueBasisPoint(*args)

    @staticmethod
    def zSpread(*args):
        return _QuantLib.BondFunctions_zSpread(*args)

    @staticmethod
    def yieldBrent(*args):
        return _QuantLib.BondFunctions_yieldBrent(*args)

    @staticmethod
    def yieldBisection(*args):
        return _QuantLib.BondFunctions_yieldBisection(*args)

    @staticmethod
    def yieldFalsePosition(*args):
        return _QuantLib.BondFunctions_yieldFalsePosition(*args)

    @staticmethod
    def yieldRidder(*args):
        return _QuantLib.BondFunctions_yieldRidder(*args)

    @staticmethod
    def yieldSecant(*args):
        return _QuantLib.BondFunctions_yieldSecant(*args)

    @staticmethod
    def yieldNewton(*args):
        return _QuantLib.BondFunctions_yieldNewton(*args)

    @staticmethod
    def yieldNewtonSafe(*args):
        return _QuantLib.BondFunctions_yieldNewtonSafe(*args)

    def __init__(self):
        _QuantLib.BondFunctions_swiginit(self, _QuantLib.new_BondFunctions())
    __swig_destroy__ = _QuantLib.delete_BondFunctions

# Register BondFunctions in _QuantLib:
_QuantLib.BondFunctions_swigregister(BondFunctions)

def BondFunctions_startDate(bond):
    return _QuantLib.BondFunctions_startDate(bond)

def BondFunctions_maturityDate(bond):
    return _QuantLib.BondFunctions_maturityDate(bond)

def BondFunctions_isTradable(*args):
    return _QuantLib.BondFunctions_isTradable(*args)

def BondFunctions_previousCashFlowDate(*args):
    return _QuantLib.BondFunctions_previousCashFlowDate(*args)

def BondFunctions_nextCashFlowDate(*args):
    return _QuantLib.BondFunctions_nextCashFlowDate(*args)

def BondFunctions_previousCashFlowAmount(*args):
    return _QuantLib.BondFunctions_previousCashFlowAmount(*args)

def BondFunctions_nextCashFlowAmount(*args):
    return _QuantLib.BondFunctions_nextCashFlowAmount(*args)

def BondFunctions_previousCouponRate(*args):
    return _QuantLib.BondFunctions_previousCouponRate(*args)

def BondFunctions_nextCouponRate(*args):
    return _QuantLib.BondFunctions_nextCouponRate(*args)

def BondFunctions_accrualStartDate(*args):
    return _QuantLib.BondFunctions_accrualStartDate(*args)

def BondFunctions_accrualEndDate(*args):
    return _QuantLib.BondFunctions_accrualEndDate(*args)

def BondFunctions_accrualPeriod(*args):
    return _QuantLib.BondFunctions_accrualPeriod(*args)

def BondFunctions_accrualDays(*args):
    return _QuantLib.BondFunctions_accrualDays(*args)

def BondFunctions_accruedPeriod(*args):
    return _QuantLib.BondFunctions_accruedPeriod(*args)

def BondFunctions_accruedDays(*args):
    return _QuantLib.BondFunctions_accruedDays(*args)

def BondFunctions_accruedAmount(*args):
    return _QuantLib.BondFunctions_accruedAmount(*args)

def BondFunctions_atmRate(*args):
    return _QuantLib.BondFunctions_atmRate(*args)

def BondFunctions_cleanPrice(*args):
    return _QuantLib.BondFunctions_cleanPrice(*args)

def BondFunctions_bps(*args):
    return _QuantLib.BondFunctions_bps(*args)

def BondFunctions_bondYield(*args):
    return _QuantLib.BondFunctions_bondYield(*args)

def BondFunctions_duration(*args):
    return _QuantLib.BondFunctions_duration(*args)

def BondFunctions_convexity(*args):
    return _QuantLib.BondFunctions_convexity(*args)

def BondFunctions_basisPointValue(*args):
    return _QuantLib.BondFunctions_basisPointValue(*args)

def BondFunctions_yieldValueBasisPoint(*args):
    return _QuantLib.BondFunctions_yieldValueBasisPoint(*args)

def BondFunctions_zSpread(*args):
    return _QuantLib.BondFunctions_zSpread(*args)

def BondFunctions_yieldBrent(*args):
    return _QuantLib.BondFunctions_yieldBrent(*args)

def BondFunctions_yieldBisection(*args):
    return _QuantLib.BondFunctions_yieldBisection(*args)

def BondFunctions_yieldFalsePosition(*args):
    return _QuantLib.BondFunctions_yieldFalsePosition(*args)

def BondFunctions_yieldRidder(*args):
    return _QuantLib.BondFunctions_yieldRidder(*args)

def BondFunctions_yieldSecant(*args):
    return _QuantLib.BondFunctions_yieldSecant(*args)

def BondFunctions_yieldNewton(*args):
    return _QuantLib.BondFunctions_yieldNewton(*args)

def BondFunctions_yieldNewtonSafe(*args):
    return _QuantLib.BondFunctions_yieldNewtonSafe(*args)

class CapFloor(Instrument):
    thisown = 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 impliedVolatility(self, price, disc, guess, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0, type=ShiftedLognormal, displacement=0.0):
        return _QuantLib.CapFloor_impliedVolatility(self, price, disc, guess, accuracy, maxEvaluations, minVol, maxVol, type, displacement)
    Cap = _QuantLib.CapFloor_Cap
    Floor = _QuantLib.CapFloor_Floor
    Collar = _QuantLib.CapFloor_Collar

    def floatingLeg(self):
        return _QuantLib.CapFloor_floatingLeg(self)

    def capRates(self):
        return _QuantLib.CapFloor_capRates(self)

    def floorRates(self):
        return _QuantLib.CapFloor_floorRates(self)

    def startDate(self):
        return _QuantLib.CapFloor_startDate(self)

    def maturityDate(self):
        return _QuantLib.CapFloor_maturityDate(self)

    def type(self):
        return _QuantLib.CapFloor_type(self)

    def atmRate(self, discountCurve):
        return _QuantLib.CapFloor_atmRate(self, discountCurve)

    def vega(self):
        return _QuantLib.CapFloor_vega(self)

    def optionletsPrice(self):
        return _QuantLib.CapFloor_optionletsPrice(self)

    def optionletsVega(self):
        return _QuantLib.CapFloor_optionletsVega(self)

    def optionletsDelta(self):
        return _QuantLib.CapFloor_optionletsDelta(self)

    def optionletsDiscountFactor(self):
        return _QuantLib.CapFloor_optionletsDiscountFactor(self)

    def optionletsAtmForward(self):
        return _QuantLib.CapFloor_optionletsAtmForward(self)

    def optionletsStdDev(self):
        return _QuantLib.CapFloor_optionletsStdDev(self)
    __swig_destroy__ = _QuantLib.delete_CapFloor

# Register CapFloor in _QuantLib:
_QuantLib.CapFloor_swigregister(CapFloor)

class Cap(CapFloor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leg, capRates):
        _QuantLib.Cap_swiginit(self, _QuantLib.new_Cap(leg, capRates))
    __swig_destroy__ = _QuantLib.delete_Cap

# Register Cap in _QuantLib:
_QuantLib.Cap_swigregister(Cap)

class Floor(CapFloor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leg, floorRates):
        _QuantLib.Floor_swiginit(self, _QuantLib.new_Floor(leg, floorRates))
    __swig_destroy__ = _QuantLib.delete_Floor

# Register Floor in _QuantLib:
_QuantLib.Floor_swigregister(Floor)

class Collar(CapFloor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leg, capRates, floorRates):
        _QuantLib.Collar_swiginit(self, _QuantLib.new_Collar(leg, capRates, floorRates))
    __swig_destroy__ = _QuantLib.delete_Collar

# Register Collar in _QuantLib:
_QuantLib.Collar_swigregister(Collar)

class BlackCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BlackCapFloorEngine_swiginit(self, _QuantLib.new_BlackCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BlackCapFloorEngine

# Register BlackCapFloorEngine in _QuantLib:
_QuantLib.BlackCapFloorEngine_swigregister(BlackCapFloorEngine)

class BachelierCapFloorEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BachelierCapFloorEngine_swiginit(self, _QuantLib.new_BachelierCapFloorEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BachelierCapFloorEngine

# Register BachelierCapFloorEngine in _QuantLib:
_QuantLib.BachelierCapFloorEngine_swigregister(BachelierCapFloorEngine)

class Dividend(CashFlow):
    thisown = 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_Dividend

# Register Dividend in _QuantLib:
_QuantLib.Dividend_swigregister(Dividend)

class FixedDividend(Dividend):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        _QuantLib.FixedDividend_swiginit(self, _QuantLib.new_FixedDividend(amount, date))
    __swig_destroy__ = _QuantLib.delete_FixedDividend

# Register FixedDividend in _QuantLib:
_QuantLib.FixedDividend_swigregister(FixedDividend)

class FractionalDividend(Dividend):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rate, date):
        _QuantLib.FractionalDividend_swiginit(self, _QuantLib.new_FractionalDividend(rate, date))
    __swig_destroy__ = _QuantLib.delete_FractionalDividend

# Register FractionalDividend in _QuantLib:
_QuantLib.FractionalDividend_swigregister(FractionalDividend)

class DividendSchedule(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.DividendSchedule___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.DividendSchedule___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.DividendSchedule___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.DividendSchedule_pop(self)

    def append(self, x):
        return _QuantLib.DividendSchedule_append(self, x)

    def empty(self):
        return _QuantLib.DividendSchedule_empty(self)

    def size(self):
        return _QuantLib.DividendSchedule_size(self)

    def swap(self, v):
        return _QuantLib.DividendSchedule_swap(self, v)

    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 clear(self):
        return _QuantLib.DividendSchedule_clear(self)

    def get_allocator(self):
        return _QuantLib.DividendSchedule_get_allocator(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):
        _QuantLib.DividendSchedule_swiginit(self, _QuantLib.new_DividendSchedule(*args))

    def push_back(self, x):
        return _QuantLib.DividendSchedule_push_back(self, x)

    def front(self):
        return _QuantLib.DividendSchedule_front(self)

    def back(self):
        return _QuantLib.DividendSchedule_back(self)

    def assign(self, n, x):
        return _QuantLib.DividendSchedule_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.DividendSchedule_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.DividendSchedule_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.DividendSchedule_reserve(self, n)

    def capacity(self):
        return _QuantLib.DividendSchedule_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DividendSchedule

# Register DividendSchedule in _QuantLib:
_QuantLib.DividendSchedule_swigregister(DividendSchedule)

class ConvertibleZeroCouponBond(Bond):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, dayCounter, schedule, redemption=100.0):
        _QuantLib.ConvertibleZeroCouponBond_swiginit(self, _QuantLib.new_ConvertibleZeroCouponBond(exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, dayCounter, schedule, redemption))
    __swig_destroy__ = _QuantLib.delete_ConvertibleZeroCouponBond

# Register ConvertibleZeroCouponBond in _QuantLib:
_QuantLib.ConvertibleZeroCouponBond_swigregister(ConvertibleZeroCouponBond)

class ConvertibleFixedCouponBond(Bond):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ConvertibleFixedCouponBond_swiginit(self, _QuantLib.new_ConvertibleFixedCouponBond(*args))
    __swig_destroy__ = _QuantLib.delete_ConvertibleFixedCouponBond

# Register ConvertibleFixedCouponBond in _QuantLib:
_QuantLib.ConvertibleFixedCouponBond_swigregister(ConvertibleFixedCouponBond)

class ConvertibleFloatingRateBond(Bond):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ConvertibleFloatingRateBond_swiginit(self, _QuantLib.new_ConvertibleFloatingRateBond(*args))
    __swig_destroy__ = _QuantLib.delete_ConvertibleFloatingRateBond

# Register ConvertibleFloatingRateBond in _QuantLib:
_QuantLib.ConvertibleFloatingRateBond_swigregister(ConvertibleFloatingRateBond)

class BinomialCRRConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialCRRConvertibleEngine_swiginit(self, _QuantLib.new_BinomialCRRConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialCRRConvertibleEngine

# Register BinomialCRRConvertibleEngine in _QuantLib:
_QuantLib.BinomialCRRConvertibleEngine_swigregister(BinomialCRRConvertibleEngine)

class BinomialJRConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialJRConvertibleEngine_swiginit(self, _QuantLib.new_BinomialJRConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJRConvertibleEngine

# Register BinomialJRConvertibleEngine in _QuantLib:
_QuantLib.BinomialJRConvertibleEngine_swigregister(BinomialJRConvertibleEngine)

class BinomialEQPConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialEQPConvertibleEngine_swiginit(self, _QuantLib.new_BinomialEQPConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialEQPConvertibleEngine

# Register BinomialEQPConvertibleEngine in _QuantLib:
_QuantLib.BinomialEQPConvertibleEngine_swigregister(BinomialEQPConvertibleEngine)

class BinomialTrigeorgisConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialTrigeorgisConvertibleEngine_swiginit(self, _QuantLib.new_BinomialTrigeorgisConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTrigeorgisConvertibleEngine

# Register BinomialTrigeorgisConvertibleEngine in _QuantLib:
_QuantLib.BinomialTrigeorgisConvertibleEngine_swigregister(BinomialTrigeorgisConvertibleEngine)

class BinomialTianConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialTianConvertibleEngine_swiginit(self, _QuantLib.new_BinomialTianConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialTianConvertibleEngine

# Register BinomialTianConvertibleEngine in _QuantLib:
_QuantLib.BinomialTianConvertibleEngine_swigregister(BinomialTianConvertibleEngine)

class BinomialLRConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialLRConvertibleEngine_swiginit(self, _QuantLib.new_BinomialLRConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialLRConvertibleEngine

# Register BinomialLRConvertibleEngine in _QuantLib:
_QuantLib.BinomialLRConvertibleEngine_swigregister(BinomialLRConvertibleEngine)

class BinomialJ4ConvertibleEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, steps):
        _QuantLib.BinomialJ4ConvertibleEngine_swiginit(self, _QuantLib.new_BinomialJ4ConvertibleEngine(arg2, steps))
    __swig_destroy__ = _QuantLib.delete_BinomialJ4ConvertibleEngine

# Register BinomialJ4ConvertibleEngine in _QuantLib:
_QuantLib.BinomialJ4ConvertibleEngine_swigregister(BinomialJ4ConvertibleEngine)


def BinomialConvertibleEngine(process, type, steps):
    type = type.lower()
    if type == "crr" or type == "coxrossrubinstein":
        cls = BinomialCRRConvertibleEngine
    elif type == "jr" or type == "jarrowrudd":
        cls = BinomialJRConvertibleEngine
    elif type == "eqp":
        cls = BinomialEQPConvertibleEngine
    elif type == "trigeorgis":
        cls = BinomialTrigeorgisConvertibleEngine
    elif type == "tian":
        cls = BinomialTianConvertibleEngine
    elif type == "lr" or type == "leisenreimer":
        cls = BinomialLRConvertibleEngine
    elif type == "j4" or type == "joshi4":
        cls = BinomialJ4ConvertibleEngine
    else:
        raise RuntimeError("unknown binomial engine type: %s" % type);
    return cls(process, steps)

class Futures(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IMM = _QuantLib.Futures_IMM
    ASX = _QuantLib.Futures_ASX

    def __init__(self):
        _QuantLib.Futures_swiginit(self, _QuantLib.new_Futures())
    __swig_destroy__ = _QuantLib.delete_Futures

# Register Futures in _QuantLib:
_QuantLib.Futures_swigregister(Futures)

class OvernightIndexFuture(object):
    thisown = 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
    Averaging = _QuantLib.OvernightIndexFuture_Averaging
    Compounding = _QuantLib.OvernightIndexFuture_Compounding
    __swig_destroy__ = _QuantLib.delete_OvernightIndexFuture

# Register OvernightIndexFuture in _QuantLib:
_QuantLib.OvernightIndexFuture_swigregister(OvernightIndexFuture)

class Pillar(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MaturityDate = _QuantLib.Pillar_MaturityDate
    LastRelevantDate = _QuantLib.Pillar_LastRelevantDate
    CustomDate = _QuantLib.Pillar_CustomDate

    def __init__(self):
        _QuantLib.Pillar_swiginit(self, _QuantLib.new_Pillar())
    __swig_destroy__ = _QuantLib.delete_Pillar

# Register Pillar in _QuantLib:
_QuantLib.Pillar_swigregister(Pillar)

class RateHelper(Observable):
    thisown = 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 quote(self):
        return _QuantLib.RateHelper_quote(self)

    def latestDate(self):
        return _QuantLib.RateHelper_latestDate(self)

    def earliestDate(self):
        return _QuantLib.RateHelper_earliestDate(self)

    def maturityDate(self):
        return _QuantLib.RateHelper_maturityDate(self)

    def latestRelevantDate(self):
        return _QuantLib.RateHelper_latestRelevantDate(self)

    def pillarDate(self):
        return _QuantLib.RateHelper_pillarDate(self)

    def impliedQuote(self):
        return _QuantLib.RateHelper_impliedQuote(self)

    def quoteError(self):
        return _QuantLib.RateHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_RateHelper

# Register RateHelper in _QuantLib:
_QuantLib.RateHelper_swigregister(RateHelper)

class DepositRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DepositRateHelper_swiginit(self, _QuantLib.new_DepositRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_DepositRateHelper

# Register DepositRateHelper in _QuantLib:
_QuantLib.DepositRateHelper_swigregister(DepositRateHelper)

class FraRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FraRateHelper_swiginit(self, _QuantLib.new_FraRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_FraRateHelper

# Register FraRateHelper in _QuantLib:
_QuantLib.FraRateHelper_swigregister(FraRateHelper)

class FuturesRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FuturesRateHelper_swiginit(self, _QuantLib.new_FuturesRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_FuturesRateHelper

# Register FuturesRateHelper in _QuantLib:
_QuantLib.FuturesRateHelper_swigregister(FuturesRateHelper)

class SwapRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SwapRateHelper_swiginit(self, _QuantLib.new_SwapRateHelper(*args))

    def spread(self):
        return _QuantLib.SwapRateHelper_spread(self)

    def swap(self):
        return _QuantLib.SwapRateHelper_swap(self)
    __swig_destroy__ = _QuantLib.delete_SwapRateHelper

# Register SwapRateHelper in _QuantLib:
_QuantLib.SwapRateHelper_swigregister(SwapRateHelper)

class BondHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, cleanPrice, bond, useCleanPrice=True):
        _QuantLib.BondHelper_swiginit(self, _QuantLib.new_BondHelper(cleanPrice, bond, useCleanPrice))

    def bond(self):
        return _QuantLib.BondHelper_bond(self)
    __swig_destroy__ = _QuantLib.delete_BondHelper

# Register BondHelper in _QuantLib:
_QuantLib.BondHelper_swigregister(BondHelper)

class FixedRateBondHelper(BondHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FixedRateBondHelper_swiginit(self, _QuantLib.new_FixedRateBondHelper(*args))

    def fixedRateBond(self):
        return _QuantLib.FixedRateBondHelper_fixedRateBond(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBondHelper

# Register FixedRateBondHelper in _QuantLib:
_QuantLib.FixedRateBondHelper_swigregister(FixedRateBondHelper)

class OISRateHelper(RateHelper):
    thisown = 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):
        _QuantLib.OISRateHelper_swiginit(self, _QuantLib.new_OISRateHelper(*args, **kwargs))

    def swap(self):
        return _QuantLib.OISRateHelper_swap(self)
    __swig_destroy__ = _QuantLib.delete_OISRateHelper

# Register OISRateHelper in _QuantLib:
_QuantLib.OISRateHelper_swigregister(OISRateHelper)

class DatedOISRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DatedOISRateHelper_swiginit(self, _QuantLib.new_DatedOISRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_DatedOISRateHelper

# Register DatedOISRateHelper in _QuantLib:
_QuantLib.DatedOISRateHelper_swigregister(DatedOISRateHelper)

class FxSwapRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FxSwapRateHelper_swiginit(self, _QuantLib.new_FxSwapRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_FxSwapRateHelper

# Register FxSwapRateHelper in _QuantLib:
_QuantLib.FxSwapRateHelper_swigregister(FxSwapRateHelper)

class OvernightIndexFutureRateHelper(RateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.OvernightIndexFutureRateHelper_swiginit(self, _QuantLib.new_OvernightIndexFutureRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_OvernightIndexFutureRateHelper

# Register OvernightIndexFutureRateHelper in _QuantLib:
_QuantLib.OvernightIndexFutureRateHelper_swigregister(OvernightIndexFutureRateHelper)

class SofrFutureRateHelper(OvernightIndexFutureRateHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SofrFutureRateHelper_swiginit(self, _QuantLib.new_SofrFutureRateHelper(*args))
    __swig_destroy__ = _QuantLib.delete_SofrFutureRateHelper

# Register SofrFutureRateHelper in _QuantLib:
_QuantLib.SofrFutureRateHelper_swigregister(SofrFutureRateHelper)

class RateHelperVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.RateHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.RateHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.RateHelperVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.RateHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.RateHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.RateHelperVector_empty(self)

    def size(self):
        return _QuantLib.RateHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.RateHelperVector_swap(self, v)

    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 clear(self):
        return _QuantLib.RateHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.RateHelperVector_get_allocator(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):
        _QuantLib.RateHelperVector_swiginit(self, _QuantLib.new_RateHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.RateHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.RateHelperVector_front(self)

    def back(self):
        return _QuantLib.RateHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.RateHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.RateHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.RateHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.RateHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.RateHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_RateHelperVector

# Register RateHelperVector in _QuantLib:
_QuantLib.RateHelperVector_swigregister(RateHelperVector)

class BondHelperVector(object):
    thisown = 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.BondHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.BondHelperVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.BondHelperVector___bool__(self)

    def __len__(self):
        return _QuantLib.BondHelperVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.BondHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.BondHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.BondHelperVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.BondHelperVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.BondHelperVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.BondHelperVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.BondHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.BondHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.BondHelperVector_empty(self)

    def size(self):
        return _QuantLib.BondHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.BondHelperVector_swap(self, v)

    def begin(self):
        return _QuantLib.BondHelperVector_begin(self)

    def end(self):
        return _QuantLib.BondHelperVector_end(self)

    def rbegin(self):
        return _QuantLib.BondHelperVector_rbegin(self)

    def rend(self):
        return _QuantLib.BondHelperVector_rend(self)

    def clear(self):
        return _QuantLib.BondHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.BondHelperVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.BondHelperVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.BondHelperVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.BondHelperVector_swiginit(self, _QuantLib.new_BondHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.BondHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.BondHelperVector_front(self)

    def back(self):
        return _QuantLib.BondHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.BondHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.BondHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.BondHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.BondHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.BondHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_BondHelperVector

# Register BondHelperVector in _QuantLib:
_QuantLib.BondHelperVector_swigregister(BondHelperVector)


def as_depositratehelper(helper):
    return _QuantLib.as_depositratehelper(helper)

def as_fraratehelper(helper):
    return _QuantLib.as_fraratehelper(helper)

def as_swapratehelper(helper):
    return _QuantLib.as_swapratehelper(helper)

def as_oisratehelper(helper):
    return _QuantLib.as_oisratehelper(helper)
class Discount(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.Discount_swiginit(self, _QuantLib.new_Discount())
    __swig_destroy__ = _QuantLib.delete_Discount

# Register Discount in _QuantLib:
_QuantLib.Discount_swigregister(Discount)

class ZeroYield(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ZeroYield_swiginit(self, _QuantLib.new_ZeroYield())
    __swig_destroy__ = _QuantLib.delete_ZeroYield

# Register ZeroYield in _QuantLib:
_QuantLib.ZeroYield_swigregister(ZeroYield)

class ForwardRate(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.ForwardRate_swiginit(self, _QuantLib.new_ForwardRate())
    __swig_destroy__ = _QuantLib.delete_ForwardRate

# Register ForwardRate in _QuantLib:
_QuantLib.ForwardRate_swigregister(ForwardRate)

class IterativeBootstrap(object):
    thisown = 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):
        _QuantLib.IterativeBootstrap_swiginit(self, _QuantLib.new_IterativeBootstrap(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_IterativeBootstrap

# Register IterativeBootstrap in _QuantLib:
_QuantLib.IterativeBootstrap_swigregister(IterativeBootstrap)

class PiecewiseFlatForward(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseFlatForward_swiginit(self, _QuantLib.new_PiecewiseFlatForward(*args))

    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

# Register PiecewiseFlatForward in _QuantLib:
_QuantLib.PiecewiseFlatForward_swigregister(PiecewiseFlatForward)

class PiecewiseLogLinearDiscount(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseLogLinearDiscount_swiginit(self, _QuantLib.new_PiecewiseLogLinearDiscount(*args))

    def dates(self):
        return _QuantLib.PiecewiseLogLinearDiscount_dates(self)

    def times(self):
        return _QuantLib.PiecewiseLogLinearDiscount_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseLogLinearDiscount_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLogLinearDiscount

# Register PiecewiseLogLinearDiscount in _QuantLib:
_QuantLib.PiecewiseLogLinearDiscount_swigregister(PiecewiseLogLinearDiscount)

class PiecewiseLinearForward(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseLinearForward_swiginit(self, _QuantLib.new_PiecewiseLinearForward(*args))

    def dates(self):
        return _QuantLib.PiecewiseLinearForward_dates(self)

    def times(self):
        return _QuantLib.PiecewiseLinearForward_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseLinearForward_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLinearForward

# Register PiecewiseLinearForward in _QuantLib:
_QuantLib.PiecewiseLinearForward_swigregister(PiecewiseLinearForward)

class PiecewiseLinearZero(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseLinearZero_swiginit(self, _QuantLib.new_PiecewiseLinearZero(*args))

    def dates(self):
        return _QuantLib.PiecewiseLinearZero_dates(self)

    def times(self):
        return _QuantLib.PiecewiseLinearZero_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseLinearZero_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLinearZero

# Register PiecewiseLinearZero in _QuantLib:
_QuantLib.PiecewiseLinearZero_swigregister(PiecewiseLinearZero)

class PiecewiseCubicZero(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseCubicZero_swiginit(self, _QuantLib.new_PiecewiseCubicZero(*args))

    def dates(self):
        return _QuantLib.PiecewiseCubicZero_dates(self)

    def times(self):
        return _QuantLib.PiecewiseCubicZero_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseCubicZero_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseCubicZero

# Register PiecewiseCubicZero in _QuantLib:
_QuantLib.PiecewiseCubicZero_swigregister(PiecewiseCubicZero)

class PiecewiseLogCubicDiscount(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseLogCubicDiscount_swiginit(self, _QuantLib.new_PiecewiseLogCubicDiscount(*args))

    def dates(self):
        return _QuantLib.PiecewiseLogCubicDiscount_dates(self)

    def times(self):
        return _QuantLib.PiecewiseLogCubicDiscount_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseLogCubicDiscount_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseLogCubicDiscount

# Register PiecewiseLogCubicDiscount in _QuantLib:
_QuantLib.PiecewiseLogCubicDiscount_swigregister(PiecewiseLogCubicDiscount)

class PiecewiseSplineCubicDiscount(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseSplineCubicDiscount_swiginit(self, _QuantLib.new_PiecewiseSplineCubicDiscount(*args))

    def dates(self):
        return _QuantLib.PiecewiseSplineCubicDiscount_dates(self)

    def times(self):
        return _QuantLib.PiecewiseSplineCubicDiscount_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseSplineCubicDiscount_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseSplineCubicDiscount

# Register PiecewiseSplineCubicDiscount in _QuantLib:
_QuantLib.PiecewiseSplineCubicDiscount_swigregister(PiecewiseSplineCubicDiscount)

class PiecewiseKrugerZero(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseKrugerZero_swiginit(self, _QuantLib.new_PiecewiseKrugerZero(*args))

    def dates(self):
        return _QuantLib.PiecewiseKrugerZero_dates(self)

    def times(self):
        return _QuantLib.PiecewiseKrugerZero_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseKrugerZero_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseKrugerZero

# Register PiecewiseKrugerZero in _QuantLib:
_QuantLib.PiecewiseKrugerZero_swigregister(PiecewiseKrugerZero)

class PiecewiseKrugerLogDiscount(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseKrugerLogDiscount_swiginit(self, _QuantLib.new_PiecewiseKrugerLogDiscount(*args))

    def dates(self):
        return _QuantLib.PiecewiseKrugerLogDiscount_dates(self)

    def times(self):
        return _QuantLib.PiecewiseKrugerLogDiscount_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseKrugerLogDiscount_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseKrugerLogDiscount

# Register PiecewiseKrugerLogDiscount in _QuantLib:
_QuantLib.PiecewiseKrugerLogDiscount_swigregister(PiecewiseKrugerLogDiscount)

class PiecewiseConvexMonotoneZero(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseConvexMonotoneZero_swiginit(self, _QuantLib.new_PiecewiseConvexMonotoneZero(*args))

    def dates(self):
        return _QuantLib.PiecewiseConvexMonotoneZero_dates(self)

    def times(self):
        return _QuantLib.PiecewiseConvexMonotoneZero_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseConvexMonotoneZero_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseConvexMonotoneZero

# Register PiecewiseConvexMonotoneZero in _QuantLib:
_QuantLib.PiecewiseConvexMonotoneZero_swigregister(PiecewiseConvexMonotoneZero)

class GlobalBootstrap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GlobalBootstrap_swiginit(self, _QuantLib.new_GlobalBootstrap(*args))
    __swig_destroy__ = _QuantLib.delete_GlobalBootstrap

# Register GlobalBootstrap in _QuantLib:
_QuantLib.GlobalBootstrap_swigregister(GlobalBootstrap)

class GlobalLinearSimpleZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, referenceDate, instruments, dayCounter, b):
        _QuantLib.GlobalLinearSimpleZeroCurve_swiginit(self, _QuantLib.new_GlobalLinearSimpleZeroCurve(referenceDate, instruments, dayCounter, b))

    def dates(self):
        return _QuantLib.GlobalLinearSimpleZeroCurve_dates(self)

    def times(self):
        return _QuantLib.GlobalLinearSimpleZeroCurve_times(self)

    def nodes(self):
        return _QuantLib.GlobalLinearSimpleZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_GlobalLinearSimpleZeroCurve

# Register GlobalLinearSimpleZeroCurve in _QuantLib:
_QuantLib.GlobalLinearSimpleZeroCurve_swigregister(GlobalLinearSimpleZeroCurve)

class DefaultProbabilityTermStructure(TermStructure):
    thisown = 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 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)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructure

# Register DefaultProbabilityTermStructure in _QuantLib:
_QuantLib.DefaultProbabilityTermStructure_swigregister(DefaultProbabilityTermStructure)

class DefaultProbabilityTermStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DefaultProbabilityTermStructureHandle_swiginit(self, _QuantLib.new_DefaultProbabilityTermStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructureHandle

    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 dayCounter(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.DefaultProbabilityTermStructureHandle_timeFromReference(self, date)

    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 enableExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_allowsExtrapolation(self)

# Register DefaultProbabilityTermStructureHandle in _QuantLib:
_QuantLib.DefaultProbabilityTermStructureHandle_swigregister(DefaultProbabilityTermStructureHandle)

class RelinkableDefaultProbabilityTermStructureHandle(DefaultProbabilityTermStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_swiginit(self, _QuantLib.new_RelinkableDefaultProbabilityTermStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableDefaultProbabilityTermStructureHandle

# Register RelinkableDefaultProbabilityTermStructureHandle in _QuantLib:
_QuantLib.RelinkableDefaultProbabilityTermStructureHandle_swigregister(RelinkableDefaultProbabilityTermStructureHandle)

class FlatHazardRate(DefaultProbabilityTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FlatHazardRate_swiginit(self, _QuantLib.new_FlatHazardRate(*args))
    __swig_destroy__ = _QuantLib.delete_FlatHazardRate

# Register FlatHazardRate in _QuantLib:
_QuantLib.FlatHazardRate_swigregister(FlatHazardRate)

class HazardRateCurve(DefaultProbabilityTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HazardRateCurve_swiginit(self, _QuantLib.new_HazardRateCurve(*args))

    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

# Register HazardRateCurve in _QuantLib:
_QuantLib.HazardRateCurve_swigregister(HazardRateCurve)

class DefaultDensityCurve(DefaultProbabilityTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DefaultDensityCurve_swiginit(self, _QuantLib.new_DefaultDensityCurve(*args))

    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

# Register DefaultDensityCurve in _QuantLib:
_QuantLib.DefaultDensityCurve_swigregister(DefaultDensityCurve)

class SurvivalProbabilityCurve(DefaultProbabilityTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SurvivalProbabilityCurve_swiginit(self, _QuantLib.new_SurvivalProbabilityCurve(*args))

    def dates(self):
        return _QuantLib.SurvivalProbabilityCurve_dates(self)

    def survivalProbabilities(self):
        return _QuantLib.SurvivalProbabilityCurve_survivalProbabilities(self)

    def nodes(self):
        return _QuantLib.SurvivalProbabilityCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_SurvivalProbabilityCurve

# Register SurvivalProbabilityCurve in _QuantLib:
_QuantLib.SurvivalProbabilityCurve_swigregister(SurvivalProbabilityCurve)

class DefaultProbabilityHelper(Observable):
    thisown = 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 quote(self):
        return _QuantLib.DefaultProbabilityHelper_quote(self)

    def latestDate(self):
        return _QuantLib.DefaultProbabilityHelper_latestDate(self)

    def earliestDate(self):
        return _QuantLib.DefaultProbabilityHelper_earliestDate(self)

    def maturityDate(self):
        return _QuantLib.DefaultProbabilityHelper_maturityDate(self)

    def latestRelevantDate(self):
        return _QuantLib.DefaultProbabilityHelper_latestRelevantDate(self)

    def pillarDate(self):
        return _QuantLib.DefaultProbabilityHelper_pillarDate(self)

    def impliedQuote(self):
        return _QuantLib.DefaultProbabilityHelper_impliedQuote(self)

    def quoteError(self):
        return _QuantLib.DefaultProbabilityHelper_quoteError(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelper

# Register DefaultProbabilityHelper in _QuantLib:
_QuantLib.DefaultProbabilityHelper_swigregister(DefaultProbabilityHelper)

class DefaultProbabilityHelperVector(object):
    thisown = 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 __getslice__(self, i, j):
        return _QuantLib.DefaultProbabilityHelperVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.DefaultProbabilityHelperVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.DefaultProbabilityHelperVector___delslice__(self, i, j)

    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 pop(self):
        return _QuantLib.DefaultProbabilityHelperVector_pop(self)

    def append(self, x):
        return _QuantLib.DefaultProbabilityHelperVector_append(self, x)

    def empty(self):
        return _QuantLib.DefaultProbabilityHelperVector_empty(self)

    def size(self):
        return _QuantLib.DefaultProbabilityHelperVector_size(self)

    def swap(self, v):
        return _QuantLib.DefaultProbabilityHelperVector_swap(self, v)

    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 clear(self):
        return _QuantLib.DefaultProbabilityHelperVector_clear(self)

    def get_allocator(self):
        return _QuantLib.DefaultProbabilityHelperVector_get_allocator(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):
        _QuantLib.DefaultProbabilityHelperVector_swiginit(self, _QuantLib.new_DefaultProbabilityHelperVector(*args))

    def push_back(self, x):
        return _QuantLib.DefaultProbabilityHelperVector_push_back(self, x)

    def front(self):
        return _QuantLib.DefaultProbabilityHelperVector_front(self)

    def back(self):
        return _QuantLib.DefaultProbabilityHelperVector_back(self)

    def assign(self, n, x):
        return _QuantLib.DefaultProbabilityHelperVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.DefaultProbabilityHelperVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.DefaultProbabilityHelperVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.DefaultProbabilityHelperVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.DefaultProbabilityHelperVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelperVector

# Register DefaultProbabilityHelperVector in _QuantLib:
_QuantLib.DefaultProbabilityHelperVector_swigregister(DefaultProbabilityHelperVector)

class SpreadCdsHelper(DefaultProbabilityHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SpreadCdsHelper_swiginit(self, _QuantLib.new_SpreadCdsHelper(*args))
    __swig_destroy__ = _QuantLib.delete_SpreadCdsHelper

# Register SpreadCdsHelper in _QuantLib:
_QuantLib.SpreadCdsHelper_swigregister(SpreadCdsHelper)

class UpfrontCdsHelper(DefaultProbabilityHelper):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.UpfrontCdsHelper_swiginit(self, _QuantLib.new_UpfrontCdsHelper(*args))
    __swig_destroy__ = _QuantLib.delete_UpfrontCdsHelper

# Register UpfrontCdsHelper in _QuantLib:
_QuantLib.UpfrontCdsHelper_swigregister(UpfrontCdsHelper)

class HazardRate(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.HazardRate_swiginit(self, _QuantLib.new_HazardRate())
    __swig_destroy__ = _QuantLib.delete_HazardRate

# Register HazardRate in _QuantLib:
_QuantLib.HazardRate_swigregister(HazardRate)

class DefaultDensity(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.DefaultDensity_swiginit(self, _QuantLib.new_DefaultDensity())
    __swig_destroy__ = _QuantLib.delete_DefaultDensity

# Register DefaultDensity in _QuantLib:
_QuantLib.DefaultDensity_swigregister(DefaultDensity)

class PiecewiseFlatHazardRate(DefaultProbabilityTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.PiecewiseFlatHazardRate_swiginit(self, _QuantLib.new_PiecewiseFlatHazardRate(*args))

    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

# Register PiecewiseFlatHazardRate in _QuantLib:
_QuantLib.PiecewiseFlatHazardRate_swigregister(PiecewiseFlatHazardRate)

class Protection(object):
    thisown = 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):
        _QuantLib.Protection_swiginit(self, _QuantLib.new_Protection())
    __swig_destroy__ = _QuantLib.delete_Protection

# Register Protection in _QuantLib:
_QuantLib.Protection_swigregister(Protection)

class Claim(object):
    thisown = 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 amount(self, defaultDate, notional, recoveryRate):
        return _QuantLib.Claim_amount(self, defaultDate, notional, recoveryRate)
    __swig_destroy__ = _QuantLib.delete_Claim

# Register Claim in _QuantLib:
_QuantLib.Claim_swigregister(Claim)

class FaceValueClaim(Claim):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.FaceValueClaim_swiginit(self, _QuantLib.new_FaceValueClaim())
    __swig_destroy__ = _QuantLib.delete_FaceValueClaim

# Register FaceValueClaim in _QuantLib:
_QuantLib.FaceValueClaim_swigregister(FaceValueClaim)

class FaceValueAccrualClaim(Claim):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, bond):
        _QuantLib.FaceValueAccrualClaim_swiginit(self, _QuantLib.new_FaceValueAccrualClaim(bond))
    __swig_destroy__ = _QuantLib.delete_FaceValueAccrualClaim

# Register FaceValueAccrualClaim in _QuantLib:
_QuantLib.FaceValueAccrualClaim_swigregister(FaceValueAccrualClaim)

class CreditDefaultSwap(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Midpoint = _QuantLib.CreditDefaultSwap_Midpoint
    ISDA = _QuantLib.CreditDefaultSwap_ISDA

    def __init__(self, *args):
        _QuantLib.CreditDefaultSwap_swiginit(self, _QuantLib.new_CreditDefaultSwap(*args))

    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)

    def conventionalSpread(self, conventionalRecovery, discountCurve, dayCounter):
        return _QuantLib.CreditDefaultSwap_conventionalSpread(self, conventionalRecovery, discountCurve, dayCounter)

    def coupons(self):
        return _QuantLib.CreditDefaultSwap_coupons(self)
    __swig_destroy__ = _QuantLib.delete_CreditDefaultSwap

# Register CreditDefaultSwap in _QuantLib:
_QuantLib.CreditDefaultSwap_swigregister(CreditDefaultSwap)

class MidPointCdsEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, probability, recoveryRate, discountCurve):
        _QuantLib.MidPointCdsEngine_swiginit(self, _QuantLib.new_MidPointCdsEngine(probability, recoveryRate, discountCurve))
    __swig_destroy__ = _QuantLib.delete_MidPointCdsEngine

# Register MidPointCdsEngine in _QuantLib:
_QuantLib.MidPointCdsEngine_swigregister(MidPointCdsEngine)

class IntegralCdsEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, integrationStep, probability, recoveryRate, discountCurve, includeSettlementDateFlows=False):
        _QuantLib.IntegralCdsEngine_swiginit(self, _QuantLib.new_IntegralCdsEngine(integrationStep, probability, recoveryRate, discountCurve, includeSettlementDateFlows))
    __swig_destroy__ = _QuantLib.delete_IntegralCdsEngine

# Register IntegralCdsEngine in _QuantLib:
_QuantLib.IntegralCdsEngine_swigregister(IntegralCdsEngine)

class IsdaCdsEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoFix = _QuantLib.IsdaCdsEngine_NoFix
    Taylor = _QuantLib.IsdaCdsEngine_Taylor
    HalfDayBias = _QuantLib.IsdaCdsEngine_HalfDayBias
    NoBias = _QuantLib.IsdaCdsEngine_NoBias
    Flat = _QuantLib.IsdaCdsEngine_Flat
    Piecewise = _QuantLib.IsdaCdsEngine_Piecewise

    def __init__(self, *args):
        _QuantLib.IsdaCdsEngine_swiginit(self, _QuantLib.new_IsdaCdsEngine(*args))
    __swig_destroy__ = _QuantLib.delete_IsdaCdsEngine

# Register IsdaCdsEngine in _QuantLib:
_QuantLib.IsdaCdsEngine_swigregister(IsdaCdsEngine)

class CdsOption(Option):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, swap, exercise, knocksOut=True):
        _QuantLib.CdsOption_swiginit(self, _QuantLib.new_CdsOption(swap, exercise, knocksOut))

    def atmRate(self):
        return _QuantLib.CdsOption_atmRate(self)

    def riskyAnnuity(self):
        return _QuantLib.CdsOption_riskyAnnuity(self)

    def impliedVolatility(self, price, termStructure, arg4, recoveryRate, accuracy=1.e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0):
        return _QuantLib.CdsOption_impliedVolatility(self, price, termStructure, arg4, recoveryRate, accuracy, maxEvaluations, minVol, maxVol)
    __swig_destroy__ = _QuantLib.delete_CdsOption

# Register CdsOption in _QuantLib:
_QuantLib.CdsOption_swigregister(CdsOption)

class BlackCdsOptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, recoveryRate, termStructure, vol):
        _QuantLib.BlackCdsOptionEngine_swiginit(self, _QuantLib.new_BlackCdsOptionEngine(arg2, recoveryRate, termStructure, vol))

    def termStructure(self):
        return _QuantLib.BlackCdsOptionEngine_termStructure(self)

    def volatility(self):
        return _QuantLib.BlackCdsOptionEngine_volatility(self)
    __swig_destroy__ = _QuantLib.delete_BlackCdsOptionEngine

# Register BlackCdsOptionEngine in _QuantLib:
_QuantLib.BlackCdsOptionEngine_swigregister(BlackCdsOptionEngine)

class DiscountCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DiscountCurve_swiginit(self, _QuantLib.new_DiscountCurve(*args))

    def times(self):
        return _QuantLib.DiscountCurve_times(self)

    def data(self):
        return _QuantLib.DiscountCurve_data(self)

    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

# Register DiscountCurve in _QuantLib:
_QuantLib.DiscountCurve_swigregister(DiscountCurve)

class MonotonicLogCubicDiscountCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MonotonicLogCubicDiscountCurve_swiginit(self, _QuantLib.new_MonotonicLogCubicDiscountCurve(*args))

    def times(self):
        return _QuantLib.MonotonicLogCubicDiscountCurve_times(self)

    def data(self):
        return _QuantLib.MonotonicLogCubicDiscountCurve_data(self)

    def dates(self):
        return _QuantLib.MonotonicLogCubicDiscountCurve_dates(self)

    def discounts(self):
        return _QuantLib.MonotonicLogCubicDiscountCurve_discounts(self)

    def nodes(self):
        return _QuantLib.MonotonicLogCubicDiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubicDiscountCurve

# Register MonotonicLogCubicDiscountCurve in _QuantLib:
_QuantLib.MonotonicLogCubicDiscountCurve_swigregister(MonotonicLogCubicDiscountCurve)

class NaturalCubicDiscountCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NaturalCubicDiscountCurve_swiginit(self, _QuantLib.new_NaturalCubicDiscountCurve(*args))

    def times(self):
        return _QuantLib.NaturalCubicDiscountCurve_times(self)

    def data(self):
        return _QuantLib.NaturalCubicDiscountCurve_data(self)

    def dates(self):
        return _QuantLib.NaturalCubicDiscountCurve_dates(self)

    def discounts(self):
        return _QuantLib.NaturalCubicDiscountCurve_discounts(self)

    def nodes(self):
        return _QuantLib.NaturalCubicDiscountCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_NaturalCubicDiscountCurve

# Register NaturalCubicDiscountCurve in _QuantLib:
_QuantLib.NaturalCubicDiscountCurve_swigregister(NaturalCubicDiscountCurve)

class NormalDistribution(object):
    thisown = 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):
        _QuantLib.NormalDistribution_swiginit(self, _QuantLib.new_NormalDistribution(average, sigma))

    def __call__(self, x):
        return _QuantLib.NormalDistribution___call__(self, x)

    def derivative(self, x):
        return _QuantLib.NormalDistribution_derivative(self, x)
    __swig_destroy__ = _QuantLib.delete_NormalDistribution

# Register NormalDistribution in _QuantLib:
_QuantLib.NormalDistribution_swigregister(NormalDistribution)

class CumulativeNormalDistribution(object):
    thisown = 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):
        _QuantLib.CumulativeNormalDistribution_swiginit(self, _QuantLib.new_CumulativeNormalDistribution(average, sigma))

    def __call__(self, x):
        return _QuantLib.CumulativeNormalDistribution___call__(self, x)

    def derivative(self, x):
        return _QuantLib.CumulativeNormalDistribution_derivative(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeNormalDistribution

# Register CumulativeNormalDistribution in _QuantLib:
_QuantLib.CumulativeNormalDistribution_swigregister(CumulativeNormalDistribution)

class InverseCumulativeNormal(object):
    thisown = 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):
        _QuantLib.InverseCumulativeNormal_swiginit(self, _QuantLib.new_InverseCumulativeNormal(average, sigma))

    def __call__(self, x):
        return _QuantLib.InverseCumulativeNormal___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeNormal

# Register InverseCumulativeNormal in _QuantLib:
_QuantLib.InverseCumulativeNormal_swigregister(InverseCumulativeNormal)

class MoroInverseCumulativeNormal(object):
    thisown = 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):
        _QuantLib.MoroInverseCumulativeNormal_swiginit(self, _QuantLib.new_MoroInverseCumulativeNormal(average, sigma))

    def __call__(self, x):
        return _QuantLib.MoroInverseCumulativeNormal___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_MoroInverseCumulativeNormal

# Register MoroInverseCumulativeNormal in _QuantLib:
_QuantLib.MoroInverseCumulativeNormal_swigregister(MoroInverseCumulativeNormal)

class BivariateCumulativeNormalDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho):
        _QuantLib.BivariateCumulativeNormalDistribution_swiginit(self, _QuantLib.new_BivariateCumulativeNormalDistribution(rho))

    def __call__(self, x, y):
        return _QuantLib.BivariateCumulativeNormalDistribution___call__(self, x, y)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistribution

# Register BivariateCumulativeNormalDistribution in _QuantLib:
_QuantLib.BivariateCumulativeNormalDistribution_swigregister(BivariateCumulativeNormalDistribution)

class BinomialDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p, n):
        _QuantLib.BinomialDistribution_swiginit(self, _QuantLib.new_BinomialDistribution(p, n))

    def __call__(self, k):
        return _QuantLib.BinomialDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_BinomialDistribution

# Register BinomialDistribution in _QuantLib:
_QuantLib.BinomialDistribution_swigregister(BinomialDistribution)

class CumulativeBinomialDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p, n):
        _QuantLib.CumulativeBinomialDistribution_swiginit(self, _QuantLib.new_CumulativeBinomialDistribution(p, n))

    def __call__(self, k):
        return _QuantLib.CumulativeBinomialDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_CumulativeBinomialDistribution

# Register CumulativeBinomialDistribution in _QuantLib:
_QuantLib.CumulativeBinomialDistribution_swigregister(CumulativeBinomialDistribution)

class BivariateCumulativeNormalDistributionDr78(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho):
        _QuantLib.BivariateCumulativeNormalDistributionDr78_swiginit(self, _QuantLib.new_BivariateCumulativeNormalDistributionDr78(rho))

    def __call__(self, a, b):
        return _QuantLib.BivariateCumulativeNormalDistributionDr78___call__(self, a, b)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistributionDr78

# Register BivariateCumulativeNormalDistributionDr78 in _QuantLib:
_QuantLib.BivariateCumulativeNormalDistributionDr78_swigregister(BivariateCumulativeNormalDistributionDr78)

class BivariateCumulativeNormalDistributionWe04DP(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rho):
        _QuantLib.BivariateCumulativeNormalDistributionWe04DP_swiginit(self, _QuantLib.new_BivariateCumulativeNormalDistributionWe04DP(rho))

    def __call__(self, a, b):
        return _QuantLib.BivariateCumulativeNormalDistributionWe04DP___call__(self, a, b)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistributionWe04DP

# Register BivariateCumulativeNormalDistributionWe04DP in _QuantLib:
_QuantLib.BivariateCumulativeNormalDistributionWe04DP_swigregister(BivariateCumulativeNormalDistributionWe04DP)

class CumulativeChiSquareDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, df):
        _QuantLib.CumulativeChiSquareDistribution_swiginit(self, _QuantLib.new_CumulativeChiSquareDistribution(df))

    def __call__(self, x):
        return _QuantLib.CumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeChiSquareDistribution

# Register CumulativeChiSquareDistribution in _QuantLib:
_QuantLib.CumulativeChiSquareDistribution_swigregister(CumulativeChiSquareDistribution)

class NonCentralCumulativeChiSquareDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, df, ncp):
        _QuantLib.NonCentralCumulativeChiSquareDistribution_swiginit(self, _QuantLib.new_NonCentralCumulativeChiSquareDistribution(df, ncp))

    def __call__(self, x):
        return _QuantLib.NonCentralCumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_NonCentralCumulativeChiSquareDistribution

# Register NonCentralCumulativeChiSquareDistribution in _QuantLib:
_QuantLib.NonCentralCumulativeChiSquareDistribution_swigregister(NonCentralCumulativeChiSquareDistribution)

class InverseNonCentralCumulativeChiSquareDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, df, ncp, maxEvaluations=10, accuracy=1e-8):
        _QuantLib.InverseNonCentralCumulativeChiSquareDistribution_swiginit(self, _QuantLib.new_InverseNonCentralCumulativeChiSquareDistribution(df, ncp, maxEvaluations, accuracy))

    def __call__(self, x):
        return _QuantLib.InverseNonCentralCumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseNonCentralCumulativeChiSquareDistribution

# Register InverseNonCentralCumulativeChiSquareDistribution in _QuantLib:
_QuantLib.InverseNonCentralCumulativeChiSquareDistribution_swigregister(InverseNonCentralCumulativeChiSquareDistribution)

class CumulativeGammaDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, a):
        _QuantLib.CumulativeGammaDistribution_swiginit(self, _QuantLib.new_CumulativeGammaDistribution(a))

    def __call__(self, x):
        return _QuantLib.CumulativeGammaDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeGammaDistribution

# Register CumulativeGammaDistribution in _QuantLib:
_QuantLib.CumulativeGammaDistribution_swigregister(CumulativeGammaDistribution)

class GammaFunction(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def logValue(self, x):
        return _QuantLib.GammaFunction_logValue(self, x)

    def __init__(self):
        _QuantLib.GammaFunction_swiginit(self, _QuantLib.new_GammaFunction())
    __swig_destroy__ = _QuantLib.delete_GammaFunction

# Register GammaFunction in _QuantLib:
_QuantLib.GammaFunction_swigregister(GammaFunction)

class PoissonDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mu):
        _QuantLib.PoissonDistribution_swiginit(self, _QuantLib.new_PoissonDistribution(mu))

    def __call__(self, k):
        return _QuantLib.PoissonDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_PoissonDistribution

# Register PoissonDistribution in _QuantLib:
_QuantLib.PoissonDistribution_swigregister(PoissonDistribution)

class CumulativePoissonDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mu):
        _QuantLib.CumulativePoissonDistribution_swiginit(self, _QuantLib.new_CumulativePoissonDistribution(mu))

    def __call__(self, k):
        return _QuantLib.CumulativePoissonDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_CumulativePoissonDistribution

# Register CumulativePoissonDistribution in _QuantLib:
_QuantLib.CumulativePoissonDistribution_swigregister(CumulativePoissonDistribution)

class InverseCumulativePoisson(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lambda_parameter):
        _QuantLib.InverseCumulativePoisson_swiginit(self, _QuantLib.new_InverseCumulativePoisson(lambda_parameter))

    def __call__(self, x):
        return _QuantLib.InverseCumulativePoisson___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativePoisson

# Register InverseCumulativePoisson in _QuantLib:
_QuantLib.InverseCumulativePoisson_swigregister(InverseCumulativePoisson)

class StudentDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        _QuantLib.StudentDistribution_swiginit(self, _QuantLib.new_StudentDistribution(n))

    def __call__(self, x):
        return _QuantLib.StudentDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_StudentDistribution

# Register StudentDistribution in _QuantLib:
_QuantLib.StudentDistribution_swigregister(StudentDistribution)

class CumulativeStudentDistribution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        _QuantLib.CumulativeStudentDistribution_swiginit(self, _QuantLib.new_CumulativeStudentDistribution(n))

    def __call__(self, x):
        return _QuantLib.CumulativeStudentDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeStudentDistribution

# Register CumulativeStudentDistribution in _QuantLib:
_QuantLib.CumulativeStudentDistribution_swigregister(CumulativeStudentDistribution)

class InverseCumulativeStudent(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, accuracy=1e-6, maxIterations=50):
        _QuantLib.InverseCumulativeStudent_swiginit(self, _QuantLib.new_InverseCumulativeStudent(n, accuracy, maxIterations))

    def __call__(self, x):
        return _QuantLib.InverseCumulativeStudent___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeStudent

# Register InverseCumulativeStudent in _QuantLib:
_QuantLib.InverseCumulativeStudent_swigregister(InverseCumulativeStudent)

class Money(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Money_swiginit(self, _QuantLib.new_Money(*args))

    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, m):
        return _QuantLib.Money___add__(self, m)

    def __sub__(self, m):
        return _QuantLib.Money___sub__(self, m)

    def __mul__(self, x):
        return _QuantLib.Money___mul__(self, x)

    def __truediv__(self, *args):
        return _QuantLib.Money___truediv__(self, *args)
    __div__ = __truediv__



    def __rmul__(self, x):
        return _QuantLib.Money___rmul__(self, x)

    def __lt__(self, other):
        return _QuantLib.Money___lt__(self, other)

    def __gt__(self, other):
        return _QuantLib.Money___gt__(self, other)

    def __le__(self, other):
        return _QuantLib.Money___le__(self, other)

    def __ge__(self, other):
        return _QuantLib.Money___ge__(self, other)

    def __cmp__(self, other):
        return _QuantLib.Money___cmp__(self, other)

    def __str__(self):
        return _QuantLib.Money___str__(self)
    NoConversion = _QuantLib.Money_NoConversion
    BaseCurrencyConversion = _QuantLib.Money_BaseCurrencyConversion
    AutomatedConversion = _QuantLib.Money_AutomatedConversion

    @staticmethod
    def setConversionType(type):
        return _QuantLib.Money_setConversionType(type)

    @staticmethod
    def setBaseCurrency(c):
        return _QuantLib.Money_setBaseCurrency(c)
    __swig_destroy__ = _QuantLib.delete_Money

# Register Money in _QuantLib:
_QuantLib.Money_swigregister(Money)

def Money_setConversionType(type):
    return _QuantLib.Money_setConversionType(type)

def Money_setBaseCurrency(c):
    return _QuantLib.Money_setBaseCurrency(c)

class ExchangeRate(object):
    thisown = 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, source, target, rate):
        _QuantLib.ExchangeRate_swiginit(self, _QuantLib.new_ExchangeRate(source, target, rate))

    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, amount):
        return _QuantLib.ExchangeRate_exchange(self, amount)

    @staticmethod
    def chain(r1, r2):
        return _QuantLib.ExchangeRate_chain(r1, r2)
    __swig_destroy__ = _QuantLib.delete_ExchangeRate

# Register ExchangeRate in _QuantLib:
_QuantLib.ExchangeRate_swigregister(ExchangeRate)

def ExchangeRate_chain(r1, r2):
    return _QuantLib.ExchangeRate_chain(r1, r2)

class ExchangeRateManager(object):
    thisown = 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

    @staticmethod
    def instance():
        return _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

# Register ExchangeRateManager in _QuantLib:
_QuantLib.ExchangeRateManager_swigregister(ExchangeRateManager)

def ExchangeRateManager_instance():
    return _QuantLib.ExchangeRateManager_instance()

class Settings(object):
    thisown = 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

    @staticmethod
    def instance():
        return _QuantLib.Settings_instance()

    def getEvaluationDate(self):
        return _QuantLib.Settings_getEvaluationDate(self)

    def setEvaluationDate(self, d):
        return _QuantLib.Settings_setEvaluationDate(self, d)

    def includeReferenceDateEvents(self, b):
        return _QuantLib.Settings_includeReferenceDateEvents(self, b)

    def includeTodaysCashFlows(self, b):
        return _QuantLib.Settings_includeTodaysCashFlows(self, b)

    def setEnforcesTodaysHistoricFixings(self, b):
        return _QuantLib.Settings_setEnforcesTodaysHistoricFixings(self, b)

    def getEnforcesTodaysHistoricFixings(self):
        return _QuantLib.Settings_getEnforcesTodaysHistoricFixings(self)

    evaluationDate = property(getEvaluationDate,setEvaluationDate,None)
    includeReferenceDateCashFlows = property(None,includeReferenceDateEvents,None)
    includeReferenceDateEvents = property(None,includeReferenceDateEvents,None)
    includeTodaysCashFlows = property(None,includeTodaysCashFlows,None)
    enforcesTodaysHistoricFixings = property(getEnforcesTodaysHistoricFixings, setEnforcesTodaysHistoricFixings, None)

    __swig_destroy__ = _QuantLib.delete_Settings

# Register Settings in _QuantLib:
_QuantLib.Settings_swigregister(Settings)

def Settings_instance():
    return _QuantLib.Settings_instance()

class Fdm1dMesher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size):
        _QuantLib.Fdm1dMesher_swiginit(self, _QuantLib.new_Fdm1dMesher(size))

    def size(self):
        return _QuantLib.Fdm1dMesher_size(self)

    def dplus(self, index):
        return _QuantLib.Fdm1dMesher_dplus(self, index)

    def dminus(self, index):
        return _QuantLib.Fdm1dMesher_dminus(self, index)

    def location(self, index):
        return _QuantLib.Fdm1dMesher_location(self, index)

    def locations(self):
        return _QuantLib.Fdm1dMesher_locations(self)
    __swig_destroy__ = _QuantLib.delete_Fdm1dMesher

# Register Fdm1dMesher in _QuantLib:
_QuantLib.Fdm1dMesher_swigregister(Fdm1dMesher)

class Fdm1dMesherVector(object):
    thisown = 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.Fdm1dMesherVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.Fdm1dMesherVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.Fdm1dMesherVector___bool__(self)

    def __len__(self):
        return _QuantLib.Fdm1dMesherVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.Fdm1dMesherVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.Fdm1dMesherVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.Fdm1dMesherVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.Fdm1dMesherVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.Fdm1dMesherVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.Fdm1dMesherVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.Fdm1dMesherVector_pop(self)

    def append(self, x):
        return _QuantLib.Fdm1dMesherVector_append(self, x)

    def empty(self):
        return _QuantLib.Fdm1dMesherVector_empty(self)

    def size(self):
        return _QuantLib.Fdm1dMesherVector_size(self)

    def swap(self, v):
        return _QuantLib.Fdm1dMesherVector_swap(self, v)

    def begin(self):
        return _QuantLib.Fdm1dMesherVector_begin(self)

    def end(self):
        return _QuantLib.Fdm1dMesherVector_end(self)

    def rbegin(self):
        return _QuantLib.Fdm1dMesherVector_rbegin(self)

    def rend(self):
        return _QuantLib.Fdm1dMesherVector_rend(self)

    def clear(self):
        return _QuantLib.Fdm1dMesherVector_clear(self)

    def get_allocator(self):
        return _QuantLib.Fdm1dMesherVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.Fdm1dMesherVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.Fdm1dMesherVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.Fdm1dMesherVector_swiginit(self, _QuantLib.new_Fdm1dMesherVector(*args))

    def push_back(self, x):
        return _QuantLib.Fdm1dMesherVector_push_back(self, x)

    def front(self):
        return _QuantLib.Fdm1dMesherVector_front(self)

    def back(self):
        return _QuantLib.Fdm1dMesherVector_back(self)

    def assign(self, n, x):
        return _QuantLib.Fdm1dMesherVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.Fdm1dMesherVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.Fdm1dMesherVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.Fdm1dMesherVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.Fdm1dMesherVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Fdm1dMesherVector

# Register Fdm1dMesherVector in _QuantLib:
_QuantLib.Fdm1dMesherVector_swigregister(Fdm1dMesherVector)

class FdmBlackScholesMesher(Fdm1dMesher):
    thisown = 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):
        _QuantLib.FdmBlackScholesMesher_swiginit(self, _QuantLib.new_FdmBlackScholesMesher(*args, **kwargs))

    @staticmethod
    def processHelper(s0, rTS, qTS, vol):
        return _QuantLib.FdmBlackScholesMesher_processHelper(s0, rTS, qTS, vol)
    __swig_destroy__ = _QuantLib.delete_FdmBlackScholesMesher

# Register FdmBlackScholesMesher in _QuantLib:
_QuantLib.FdmBlackScholesMesher_swigregister(FdmBlackScholesMesher)

def FdmBlackScholesMesher_processHelper(s0, rTS, qTS, vol):
    return _QuantLib.FdmBlackScholesMesher_processHelper(s0, rTS, qTS, vol)

class Concentrating1dMesherPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg3, arg4):
        _QuantLib.Concentrating1dMesherPoint_swiginit(self, _QuantLib.new_Concentrating1dMesherPoint(arg2, arg3, arg4))

    def first(self):
        return _QuantLib.Concentrating1dMesherPoint_first(self)

    def second(self):
        return _QuantLib.Concentrating1dMesherPoint_second(self)

    def third(self):
        return _QuantLib.Concentrating1dMesherPoint_third(self)
    __swig_destroy__ = _QuantLib.delete_Concentrating1dMesherPoint

# Register Concentrating1dMesherPoint in _QuantLib:
_QuantLib.Concentrating1dMesherPoint_swigregister(Concentrating1dMesherPoint)

class Concentrating1dMesherPointVector(object):
    thisown = 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.Concentrating1dMesherPointVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.Concentrating1dMesherPointVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.Concentrating1dMesherPointVector___bool__(self)

    def __len__(self):
        return _QuantLib.Concentrating1dMesherPointVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.Concentrating1dMesherPointVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.Concentrating1dMesherPointVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.Concentrating1dMesherPointVector_pop(self)

    def append(self, x):
        return _QuantLib.Concentrating1dMesherPointVector_append(self, x)

    def empty(self):
        return _QuantLib.Concentrating1dMesherPointVector_empty(self)

    def size(self):
        return _QuantLib.Concentrating1dMesherPointVector_size(self)

    def swap(self, v):
        return _QuantLib.Concentrating1dMesherPointVector_swap(self, v)

    def begin(self):
        return _QuantLib.Concentrating1dMesherPointVector_begin(self)

    def end(self):
        return _QuantLib.Concentrating1dMesherPointVector_end(self)

    def rbegin(self):
        return _QuantLib.Concentrating1dMesherPointVector_rbegin(self)

    def rend(self):
        return _QuantLib.Concentrating1dMesherPointVector_rend(self)

    def clear(self):
        return _QuantLib.Concentrating1dMesherPointVector_clear(self)

    def get_allocator(self):
        return _QuantLib.Concentrating1dMesherPointVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.Concentrating1dMesherPointVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.Concentrating1dMesherPointVector_swiginit(self, _QuantLib.new_Concentrating1dMesherPointVector(*args))

    def push_back(self, x):
        return _QuantLib.Concentrating1dMesherPointVector_push_back(self, x)

    def front(self):
        return _QuantLib.Concentrating1dMesherPointVector_front(self)

    def back(self):
        return _QuantLib.Concentrating1dMesherPointVector_back(self)

    def assign(self, n, x):
        return _QuantLib.Concentrating1dMesherPointVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.Concentrating1dMesherPointVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.Concentrating1dMesherPointVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.Concentrating1dMesherPointVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_Concentrating1dMesherPointVector

# Register Concentrating1dMesherPointVector in _QuantLib:
_QuantLib.Concentrating1dMesherPointVector_swigregister(Concentrating1dMesherPointVector)

class Concentrating1dMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Concentrating1dMesher_swiginit(self, _QuantLib.new_Concentrating1dMesher(*args))
    __swig_destroy__ = _QuantLib.delete_Concentrating1dMesher

# Register Concentrating1dMesher in _QuantLib:
_QuantLib.Concentrating1dMesher_swigregister(Concentrating1dMesher)

class ExponentialJump1dMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, steps, beta, jumpIntensity, eta, eps=1e-3):
        _QuantLib.ExponentialJump1dMesher_swiginit(self, _QuantLib.new_ExponentialJump1dMesher(steps, beta, jumpIntensity, eta, eps))
    __swig_destroy__ = _QuantLib.delete_ExponentialJump1dMesher

# Register ExponentialJump1dMesher in _QuantLib:
_QuantLib.ExponentialJump1dMesher_swigregister(ExponentialJump1dMesher)

class FdmCEV1dMesher(Fdm1dMesher):
    thisown = 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):
        _QuantLib.FdmCEV1dMesher_swiginit(self, _QuantLib.new_FdmCEV1dMesher(*args, **kwargs))
    __swig_destroy__ = _QuantLib.delete_FdmCEV1dMesher

# Register FdmCEV1dMesher in _QuantLib:
_QuantLib.FdmCEV1dMesher_swigregister(FdmCEV1dMesher)

class FdmHestonVarianceMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size, process, maturity, tAvgSteps=10, epsilon=0.0001):
        _QuantLib.FdmHestonVarianceMesher_swiginit(self, _QuantLib.new_FdmHestonVarianceMesher(size, process, maturity, tAvgSteps, epsilon))

    def volaEstimate(self):
        return _QuantLib.FdmHestonVarianceMesher_volaEstimate(self)
    __swig_destroy__ = _QuantLib.delete_FdmHestonVarianceMesher

# Register FdmHestonVarianceMesher in _QuantLib:
_QuantLib.FdmHestonVarianceMesher_swigregister(FdmHestonVarianceMesher)

class FdmHestonLocalVolatilityVarianceMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size, process, leverageFct, maturity, tAvgSteps=10, epsilon=0.0001):
        _QuantLib.FdmHestonLocalVolatilityVarianceMesher_swiginit(self, _QuantLib.new_FdmHestonLocalVolatilityVarianceMesher(size, process, leverageFct, maturity, tAvgSteps, epsilon))

    def volaEstimate(self):
        return _QuantLib.FdmHestonLocalVolatilityVarianceMesher_volaEstimate(self)
    __swig_destroy__ = _QuantLib.delete_FdmHestonLocalVolatilityVarianceMesher

# Register FdmHestonLocalVolatilityVarianceMesher in _QuantLib:
_QuantLib.FdmHestonLocalVolatilityVarianceMesher_swigregister(FdmHestonLocalVolatilityVarianceMesher)

class FdmSimpleProcess1dMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmSimpleProcess1dMesher_swiginit(self, _QuantLib.new_FdmSimpleProcess1dMesher(*args))
    __swig_destroy__ = _QuantLib.delete_FdmSimpleProcess1dMesher

# Register FdmSimpleProcess1dMesher in _QuantLib:
_QuantLib.FdmSimpleProcess1dMesher_swigregister(FdmSimpleProcess1dMesher)

class Uniform1dMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, start, end, size):
        _QuantLib.Uniform1dMesher_swiginit(self, _QuantLib.new_Uniform1dMesher(start, end, size))
    __swig_destroy__ = _QuantLib.delete_Uniform1dMesher

# Register Uniform1dMesher in _QuantLib:
_QuantLib.Uniform1dMesher_swigregister(Uniform1dMesher)

class Predefined1dMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, x):
        _QuantLib.Predefined1dMesher_swiginit(self, _QuantLib.new_Predefined1dMesher(x))
    __swig_destroy__ = _QuantLib.delete_Predefined1dMesher

# Register Predefined1dMesher in _QuantLib:
_QuantLib.Predefined1dMesher_swigregister(Predefined1dMesher)

class Glued1dMesher(Fdm1dMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, leftMesher, rightMesher):
        _QuantLib.Glued1dMesher_swiginit(self, _QuantLib.new_Glued1dMesher(leftMesher, rightMesher))
    __swig_destroy__ = _QuantLib.delete_Glued1dMesher

# Register Glued1dMesher in _QuantLib:
_QuantLib.Glued1dMesher_swigregister(Glued1dMesher)

class FdmLinearOpIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dim, coordinates, index):
        _QuantLib.FdmLinearOpIterator_swiginit(self, _QuantLib.new_FdmLinearOpIterator(dim, coordinates, index))

    def coordinates(self):
        return _QuantLib.FdmLinearOpIterator_coordinates(self)

    def increment(self):
        return _QuantLib.FdmLinearOpIterator_increment(self)

    def notEqual(self, iterator):
        return _QuantLib.FdmLinearOpIterator_notEqual(self, iterator)

    def index(self):
        return _QuantLib.FdmLinearOpIterator_index(self)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpIterator

# Register FdmLinearOpIterator in _QuantLib:
_QuantLib.FdmLinearOpIterator_swigregister(FdmLinearOpIterator)

class FdmLinearOpLayout(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dim):
        _QuantLib.FdmLinearOpLayout_swiginit(self, _QuantLib.new_FdmLinearOpLayout(dim))

    def spacing(self):
        return _QuantLib.FdmLinearOpLayout_spacing(self)

    def dim(self):
        return _QuantLib.FdmLinearOpLayout_dim(self)

    def index(self, coordinates):
        return _QuantLib.FdmLinearOpLayout_index(self, coordinates)

    def begin(self):
        return _QuantLib.FdmLinearOpLayout_begin(self)

    def end(self):
        return _QuantLib.FdmLinearOpLayout_end(self)

    def size(self):
        return _QuantLib.FdmLinearOpLayout_size(self)

    def neighbourhood(self, *args):
        return _QuantLib.FdmLinearOpLayout_neighbourhood(self, *args)

    def iter_neighbourhood(self, iterator, i, offset):
        return _QuantLib.FdmLinearOpLayout_iter_neighbourhood(self, iterator, i, offset)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpLayout

# Register FdmLinearOpLayout in _QuantLib:
_QuantLib.FdmLinearOpLayout_swigregister(FdmLinearOpLayout)

class FdmMesher(object):
    thisown = 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_FdmMesher

# Register FdmMesher in _QuantLib:
_QuantLib.FdmMesher_swigregister(FdmMesher)

class FdmMesherComposite(FdmMesher):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmMesherComposite_swiginit(self, _QuantLib.new_FdmMesherComposite(*args))

    def dplus(self, iter, direction):
        return _QuantLib.FdmMesherComposite_dplus(self, iter, direction)

    def dminus(self, iter, direction):
        return _QuantLib.FdmMesherComposite_dminus(self, iter, direction)

    def location(self, iter, direction):
        return _QuantLib.FdmMesherComposite_location(self, iter, direction)

    def locations(self, direction):
        return _QuantLib.FdmMesherComposite_locations(self, direction)

    def layout(self):
        return _QuantLib.FdmMesherComposite_layout(self)

    def getFdm1dMeshers(self):
        return _QuantLib.FdmMesherComposite_getFdm1dMeshers(self)
    __swig_destroy__ = _QuantLib.delete_FdmMesherComposite

# Register FdmMesherComposite in _QuantLib:
_QuantLib.FdmMesherComposite_swigregister(FdmMesherComposite)

class FdmLinearOp(object):
    thisown = 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 apply(self, r):
        return _QuantLib.FdmLinearOp_apply(self, r)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOp

# Register FdmLinearOp in _QuantLib:
_QuantLib.FdmLinearOp_swigregister(FdmLinearOp)

class FdmLinearOpComposite(FdmLinearOp):
    thisown = 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 size(self):
        return _QuantLib.FdmLinearOpComposite_size(self)

    def setTime(self, t1, t2):
        return _QuantLib.FdmLinearOpComposite_setTime(self, t1, t2)

    def apply_mixed(self, r):
        return _QuantLib.FdmLinearOpComposite_apply_mixed(self, r)

    def apply_direction(self, direction, r):
        return _QuantLib.FdmLinearOpComposite_apply_direction(self, direction, r)

    def solve_splitting(self, direction, r, s):
        return _QuantLib.FdmLinearOpComposite_solve_splitting(self, direction, r, s)

    def preconditioner(self, r, s):
        return _QuantLib.FdmLinearOpComposite_preconditioner(self, r, s)
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpComposite

# Register FdmLinearOpComposite in _QuantLib:
_QuantLib.FdmLinearOpComposite_swigregister(FdmLinearOpComposite)

class FdmLinearOpCompositeProxy(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        _QuantLib.FdmLinearOpCompositeProxy_swiginit(self, _QuantLib.new_FdmLinearOpCompositeProxy(callback))
    __swig_destroy__ = _QuantLib.delete_FdmLinearOpCompositeProxy

# Register FdmLinearOpCompositeProxy in _QuantLib:
_QuantLib.FdmLinearOpCompositeProxy_swigregister(FdmLinearOpCompositeProxy)

class FdmBoundaryCondition(object):
    thisown = 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
    NoSide = _QuantLib.FdmBoundaryCondition_NoSide
    Upper = _QuantLib.FdmBoundaryCondition_Upper
    Lower = _QuantLib.FdmBoundaryCondition_Lower

    def applyBeforeApplying(self, arg2):
        return _QuantLib.FdmBoundaryCondition_applyBeforeApplying(self, arg2)

    def applyAfterApplying(self, arg2):
        return _QuantLib.FdmBoundaryCondition_applyAfterApplying(self, arg2)

    def applyBeforeSolving(self, arg2, rhs):
        return _QuantLib.FdmBoundaryCondition_applyBeforeSolving(self, arg2, rhs)

    def applyAfterSolving(self, arg2):
        return _QuantLib.FdmBoundaryCondition_applyAfterSolving(self, arg2)

    def setTime(self, t):
        return _QuantLib.FdmBoundaryCondition_setTime(self, t)
    __swig_destroy__ = _QuantLib.delete_FdmBoundaryCondition

# Register FdmBoundaryCondition in _QuantLib:
_QuantLib.FdmBoundaryCondition_swigregister(FdmBoundaryCondition)

class FdmBoundaryConditionSet(object):
    thisown = 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.FdmBoundaryConditionSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.FdmBoundaryConditionSet___nonzero__(self)

    def __bool__(self):
        return _QuantLib.FdmBoundaryConditionSet___bool__(self)

    def __len__(self):
        return _QuantLib.FdmBoundaryConditionSet___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.FdmBoundaryConditionSet___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.FdmBoundaryConditionSet___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.FdmBoundaryConditionSet___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.FdmBoundaryConditionSet___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.FdmBoundaryConditionSet___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.FdmBoundaryConditionSet___setitem__(self, *args)

    def pop(self):
        return _QuantLib.FdmBoundaryConditionSet_pop(self)

    def append(self, x):
        return _QuantLib.FdmBoundaryConditionSet_append(self, x)

    def empty(self):
        return _QuantLib.FdmBoundaryConditionSet_empty(self)

    def size(self):
        return _QuantLib.FdmBoundaryConditionSet_size(self)

    def swap(self, v):
        return _QuantLib.FdmBoundaryConditionSet_swap(self, v)

    def begin(self):
        return _QuantLib.FdmBoundaryConditionSet_begin(self)

    def end(self):
        return _QuantLib.FdmBoundaryConditionSet_end(self)

    def rbegin(self):
        return _QuantLib.FdmBoundaryConditionSet_rbegin(self)

    def rend(self):
        return _QuantLib.FdmBoundaryConditionSet_rend(self)

    def clear(self):
        return _QuantLib.FdmBoundaryConditionSet_clear(self)

    def get_allocator(self):
        return _QuantLib.FdmBoundaryConditionSet_get_allocator(self)

    def pop_back(self):
        return _QuantLib.FdmBoundaryConditionSet_pop_back(self)

    def erase(self, *args):
        return _QuantLib.FdmBoundaryConditionSet_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.FdmBoundaryConditionSet_swiginit(self, _QuantLib.new_FdmBoundaryConditionSet(*args))

    def push_back(self, x):
        return _QuantLib.FdmBoundaryConditionSet_push_back(self, x)

    def front(self):
        return _QuantLib.FdmBoundaryConditionSet_front(self)

    def back(self):
        return _QuantLib.FdmBoundaryConditionSet_back(self)

    def assign(self, n, x):
        return _QuantLib.FdmBoundaryConditionSet_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.FdmBoundaryConditionSet_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.FdmBoundaryConditionSet_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.FdmBoundaryConditionSet_reserve(self, n)

    def capacity(self):
        return _QuantLib.FdmBoundaryConditionSet_capacity(self)
    __swig_destroy__ = _QuantLib.delete_FdmBoundaryConditionSet

# Register FdmBoundaryConditionSet in _QuantLib:
_QuantLib.FdmBoundaryConditionSet_swigregister(FdmBoundaryConditionSet)

class FdmDirichletBoundary(FdmBoundaryCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, valueOnBoundary, direction, side):
        _QuantLib.FdmDirichletBoundary_swiginit(self, _QuantLib.new_FdmDirichletBoundary(mesher, valueOnBoundary, direction, side))

    def applyAfterApplying(self, *args):
        return _QuantLib.FdmDirichletBoundary_applyAfterApplying(self, *args)
    __swig_destroy__ = _QuantLib.delete_FdmDirichletBoundary

# Register FdmDirichletBoundary in _QuantLib:
_QuantLib.FdmDirichletBoundary_swigregister(FdmDirichletBoundary)

class FdmDiscountDirichletBoundary(FdmBoundaryCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, rTS, maturityTime, valueOnBoundary, direction, side):
        _QuantLib.FdmDiscountDirichletBoundary_swiginit(self, _QuantLib.new_FdmDiscountDirichletBoundary(mesher, rTS, maturityTime, valueOnBoundary, direction, side))
    __swig_destroy__ = _QuantLib.delete_FdmDiscountDirichletBoundary

# Register FdmDiscountDirichletBoundary in _QuantLib:
_QuantLib.FdmDiscountDirichletBoundary_swigregister(FdmDiscountDirichletBoundary)

class FdmTimeDepDirichletBoundary(FdmBoundaryCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, function, direction, side):
        _QuantLib.FdmTimeDepDirichletBoundary_swiginit(self, _QuantLib.new_FdmTimeDepDirichletBoundary(mesher, function, direction, side))
    __swig_destroy__ = _QuantLib.delete_FdmTimeDepDirichletBoundary

# Register FdmTimeDepDirichletBoundary in _QuantLib:
_QuantLib.FdmTimeDepDirichletBoundary_swigregister(FdmTimeDepDirichletBoundary)

class FdmBatesOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmBatesOp_swiginit(self, _QuantLib.new_FdmBatesOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmBatesOp

# Register FdmBatesOp in _QuantLib:
_QuantLib.FdmBatesOp_swigregister(FdmBatesOp)

class FdmBlackScholesOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmBlackScholesOp_swiginit(self, _QuantLib.new_FdmBlackScholesOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmBlackScholesOp

# Register FdmBlackScholesOp in _QuantLib:
_QuantLib.FdmBlackScholesOp_swigregister(FdmBlackScholesOp)

class Fdm2dBlackScholesOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Fdm2dBlackScholesOp_swiginit(self, _QuantLib.new_Fdm2dBlackScholesOp(*args))
    __swig_destroy__ = _QuantLib.delete_Fdm2dBlackScholesOp

# Register Fdm2dBlackScholesOp in _QuantLib:
_QuantLib.Fdm2dBlackScholesOp_swigregister(Fdm2dBlackScholesOp)

class FdmCEVOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, rTS, f0, alpha, beta, direction):
        _QuantLib.FdmCEVOp_swiginit(self, _QuantLib.new_FdmCEVOp(mesher, rTS, f0, alpha, beta, direction))
    __swig_destroy__ = _QuantLib.delete_FdmCEVOp

# Register FdmCEVOp in _QuantLib:
_QuantLib.FdmCEVOp_swigregister(FdmCEVOp)

class FdmG2Op(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, model, direction1, direction2):
        _QuantLib.FdmG2Op_swiginit(self, _QuantLib.new_FdmG2Op(mesher, model, direction1, direction2))
    __swig_destroy__ = _QuantLib.delete_FdmG2Op

# Register FdmG2Op in _QuantLib:
_QuantLib.FdmG2Op_swigregister(FdmG2Op)

class FdmHestonHullWhiteOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, hestonProcess, hwProcess, equityShortRateCorrelation):
        _QuantLib.FdmHestonHullWhiteOp_swiginit(self, _QuantLib.new_FdmHestonHullWhiteOp(mesher, hestonProcess, hwProcess, equityShortRateCorrelation))
    __swig_destroy__ = _QuantLib.delete_FdmHestonHullWhiteOp

# Register FdmHestonHullWhiteOp in _QuantLib:
_QuantLib.FdmHestonHullWhiteOp_swigregister(FdmHestonHullWhiteOp)

class FdmHestonOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmHestonOp_swiginit(self, _QuantLib.new_FdmHestonOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmHestonOp

# Register FdmHestonOp in _QuantLib:
_QuantLib.FdmHestonOp_swigregister(FdmHestonOp)

class FdmHullWhiteOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, model, direction):
        _QuantLib.FdmHullWhiteOp_swiginit(self, _QuantLib.new_FdmHullWhiteOp(mesher, model, direction))
    __swig_destroy__ = _QuantLib.delete_FdmHullWhiteOp

# Register FdmHullWhiteOp in _QuantLib:
_QuantLib.FdmHullWhiteOp_swigregister(FdmHullWhiteOp)

class FdmLocalVolFwdOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, spot, rTS, qTS, localVol, direction=0):
        _QuantLib.FdmLocalVolFwdOp_swiginit(self, _QuantLib.new_FdmLocalVolFwdOp(mesher, spot, rTS, qTS, localVol, direction))
    __swig_destroy__ = _QuantLib.delete_FdmLocalVolFwdOp

# Register FdmLocalVolFwdOp in _QuantLib:
_QuantLib.FdmLocalVolFwdOp_swigregister(FdmLocalVolFwdOp)

class FdmOrnsteinUhlenbeckOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, p, rTS, direction=0):
        _QuantLib.FdmOrnsteinUhlenbeckOp_swiginit(self, _QuantLib.new_FdmOrnsteinUhlenbeckOp(mesher, p, rTS, direction))
    __swig_destroy__ = _QuantLib.delete_FdmOrnsteinUhlenbeckOp

# Register FdmOrnsteinUhlenbeckOp in _QuantLib:
_QuantLib.FdmOrnsteinUhlenbeckOp_swigregister(FdmOrnsteinUhlenbeckOp)

class FdmSabrOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, rTS, f0, alpha, beta, nu, rho):
        _QuantLib.FdmSabrOp_swiginit(self, _QuantLib.new_FdmSabrOp(mesher, rTS, f0, alpha, beta, nu, rho))
    __swig_destroy__ = _QuantLib.delete_FdmSabrOp

# Register FdmSabrOp in _QuantLib:
_QuantLib.FdmSabrOp_swigregister(FdmSabrOp)

class FdmZabrOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, beta, nu, rho, gamma):
        _QuantLib.FdmZabrOp_swiginit(self, _QuantLib.new_FdmZabrOp(mesher, beta, nu, rho, gamma))
    __swig_destroy__ = _QuantLib.delete_FdmZabrOp

# Register FdmZabrOp in _QuantLib:
_QuantLib.FdmZabrOp_swigregister(FdmZabrOp)

class FdmDupire1dOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, localVolatility):
        _QuantLib.FdmDupire1dOp_swiginit(self, _QuantLib.new_FdmDupire1dOp(mesher, localVolatility))
    __swig_destroy__ = _QuantLib.delete_FdmDupire1dOp

# Register FdmDupire1dOp in _QuantLib:
_QuantLib.FdmDupire1dOp_swigregister(FdmDupire1dOp)

class FdmBlackScholesFwdOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmBlackScholesFwdOp_swiginit(self, _QuantLib.new_FdmBlackScholesFwdOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmBlackScholesFwdOp

# Register FdmBlackScholesFwdOp in _QuantLib:
_QuantLib.FdmBlackScholesFwdOp_swigregister(FdmBlackScholesFwdOp)

class FdmSquareRootFwdOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Plain = _QuantLib.FdmSquareRootFwdOp_Plain
    Power = _QuantLib.FdmSquareRootFwdOp_Power
    Log = _QuantLib.FdmSquareRootFwdOp_Log

    def __init__(self, *args):
        _QuantLib.FdmSquareRootFwdOp_swiginit(self, _QuantLib.new_FdmSquareRootFwdOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmSquareRootFwdOp

# Register FdmSquareRootFwdOp in _QuantLib:
_QuantLib.FdmSquareRootFwdOp_swigregister(FdmSquareRootFwdOp)

class FdmHestonFwdOp(FdmLinearOpComposite):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmHestonFwdOp_swiginit(self, _QuantLib.new_FdmHestonFwdOp(*args))
    __swig_destroy__ = _QuantLib.delete_FdmHestonFwdOp

# Register FdmHestonFwdOp in _QuantLib:
_QuantLib.FdmHestonFwdOp_swigregister(FdmHestonFwdOp)

class TripleBandLinearOp(FdmLinearOp):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, mesher):
        _QuantLib.TripleBandLinearOp_swiginit(self, _QuantLib.new_TripleBandLinearOp(direction, mesher))

    def apply(self, r):
        return _QuantLib.TripleBandLinearOp_apply(self, r)

    def solve_splitting(self, r, a, b=1.0):
        return _QuantLib.TripleBandLinearOp_solve_splitting(self, r, a, b)

    def mult(self, u):
        return _QuantLib.TripleBandLinearOp_mult(self, u)

    def multR(self, u):
        return _QuantLib.TripleBandLinearOp_multR(self, u)

    def add(self, *args):
        return _QuantLib.TripleBandLinearOp_add(self, *args)

    def axpyb(self, a, x, y, b):
        return _QuantLib.TripleBandLinearOp_axpyb(self, a, x, y, b)

    def swap(self, m):
        return _QuantLib.TripleBandLinearOp_swap(self, m)
    __swig_destroy__ = _QuantLib.delete_TripleBandLinearOp

# Register TripleBandLinearOp in _QuantLib:
_QuantLib.TripleBandLinearOp_swigregister(TripleBandLinearOp)

class FirstDerivativeOp(TripleBandLinearOp):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, mesher):
        _QuantLib.FirstDerivativeOp_swiginit(self, _QuantLib.new_FirstDerivativeOp(direction, mesher))
    __swig_destroy__ = _QuantLib.delete_FirstDerivativeOp

# Register FirstDerivativeOp in _QuantLib:
_QuantLib.FirstDerivativeOp_swigregister(FirstDerivativeOp)

class SecondDerivativeOp(TripleBandLinearOp):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, mesher):
        _QuantLib.SecondDerivativeOp_swiginit(self, _QuantLib.new_SecondDerivativeOp(direction, mesher))
    __swig_destroy__ = _QuantLib.delete_SecondDerivativeOp

# Register SecondDerivativeOp in _QuantLib:
_QuantLib.SecondDerivativeOp_swigregister(SecondDerivativeOp)

class NinePointLinearOp(FdmLinearOp):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, d0, d1, mesher):
        _QuantLib.NinePointLinearOp_swiginit(self, _QuantLib.new_NinePointLinearOp(d0, d1, mesher))
    __swig_destroy__ = _QuantLib.delete_NinePointLinearOp

# Register NinePointLinearOp in _QuantLib:
_QuantLib.NinePointLinearOp_swigregister(NinePointLinearOp)

class SecondOrderMixedDerivativeOp(NinePointLinearOp):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, d0, d1, mesher):
        _QuantLib.SecondOrderMixedDerivativeOp_swiginit(self, _QuantLib.new_SecondOrderMixedDerivativeOp(d0, d1, mesher))
    __swig_destroy__ = _QuantLib.delete_SecondOrderMixedDerivativeOp

# Register SecondOrderMixedDerivativeOp in _QuantLib:
_QuantLib.SecondOrderMixedDerivativeOp_swigregister(SecondOrderMixedDerivativeOp)

class NthOrderDerivativeOp(FdmLinearOp):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, direction, order, nPoints, mesher):
        _QuantLib.NthOrderDerivativeOp_swiginit(self, _QuantLib.new_NthOrderDerivativeOp(direction, order, nPoints, mesher))
    __swig_destroy__ = _QuantLib.delete_NthOrderDerivativeOp

# Register NthOrderDerivativeOp in _QuantLib:
_QuantLib.NthOrderDerivativeOp_swigregister(NthOrderDerivativeOp)

class CraigSneydScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CraigSneydScheme_swiginit(self, _QuantLib.new_CraigSneydScheme(*args))

    def step(self, a, t):
        return _QuantLib.CraigSneydScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.CraigSneydScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_CraigSneydScheme

# Register CraigSneydScheme in _QuantLib:
_QuantLib.CraigSneydScheme_swigregister(CraigSneydScheme)

class ImplicitEulerScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BiCGstab = _QuantLib.ImplicitEulerScheme_BiCGstab
    GMRES = _QuantLib.ImplicitEulerScheme_GMRES

    def __init__(self, *args, **kwargs):
        _QuantLib.ImplicitEulerScheme_swiginit(self, _QuantLib.new_ImplicitEulerScheme(*args, **kwargs))

    def step(self, a, t):
        return _QuantLib.ImplicitEulerScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.ImplicitEulerScheme_setStep(self, dt)

    def numberOfIterations(self):
        return _QuantLib.ImplicitEulerScheme_numberOfIterations(self)
    __swig_destroy__ = _QuantLib.delete_ImplicitEulerScheme

# Register ImplicitEulerScheme in _QuantLib:
_QuantLib.ImplicitEulerScheme_swigregister(ImplicitEulerScheme)

class CrankNicolsonScheme(object):
    thisown = 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):
        _QuantLib.CrankNicolsonScheme_swiginit(self, _QuantLib.new_CrankNicolsonScheme(*args, **kwargs))

    def step(self, a, t):
        return _QuantLib.CrankNicolsonScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.CrankNicolsonScheme_setStep(self, dt)

    def numberOfIterations(self):
        return _QuantLib.CrankNicolsonScheme_numberOfIterations(self)
    __swig_destroy__ = _QuantLib.delete_CrankNicolsonScheme

# Register CrankNicolsonScheme in _QuantLib:
_QuantLib.CrankNicolsonScheme_swigregister(CrankNicolsonScheme)

class DouglasScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.DouglasScheme_swiginit(self, _QuantLib.new_DouglasScheme(*args))

    def step(self, a, t):
        return _QuantLib.DouglasScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.DouglasScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_DouglasScheme

# Register DouglasScheme in _QuantLib:
_QuantLib.DouglasScheme_swigregister(DouglasScheme)

class ExplicitEulerScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ExplicitEulerScheme_swiginit(self, _QuantLib.new_ExplicitEulerScheme(*args))

    def step(self, a, t):
        return _QuantLib.ExplicitEulerScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.ExplicitEulerScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_ExplicitEulerScheme

# Register ExplicitEulerScheme in _QuantLib:
_QuantLib.ExplicitEulerScheme_swigregister(ExplicitEulerScheme)

class HundsdorferScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HundsdorferScheme_swiginit(self, _QuantLib.new_HundsdorferScheme(*args))

    def step(self, a, t):
        return _QuantLib.HundsdorferScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.HundsdorferScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_HundsdorferScheme

# Register HundsdorferScheme in _QuantLib:
_QuantLib.HundsdorferScheme_swigregister(HundsdorferScheme)

class MethodOfLinesScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MethodOfLinesScheme_swiginit(self, _QuantLib.new_MethodOfLinesScheme(*args))

    def step(self, a, t):
        return _QuantLib.MethodOfLinesScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.MethodOfLinesScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_MethodOfLinesScheme

# Register MethodOfLinesScheme in _QuantLib:
_QuantLib.MethodOfLinesScheme_swigregister(MethodOfLinesScheme)

class ModifiedCraigSneydScheme(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ModifiedCraigSneydScheme_swiginit(self, _QuantLib.new_ModifiedCraigSneydScheme(*args))

    def step(self, a, t):
        return _QuantLib.ModifiedCraigSneydScheme_step(self, a, t)

    def setStep(self, dt):
        return _QuantLib.ModifiedCraigSneydScheme_setStep(self, dt)
    __swig_destroy__ = _QuantLib.delete_ModifiedCraigSneydScheme

# Register ModifiedCraigSneydScheme in _QuantLib:
_QuantLib.ModifiedCraigSneydScheme_swigregister(ModifiedCraigSneydScheme)

class FdmStepCondition(object):
    thisown = 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 applyTo(self, a, t):
        return _QuantLib.FdmStepCondition_applyTo(self, a, t)
    __swig_destroy__ = _QuantLib.delete_FdmStepCondition

# Register FdmStepCondition in _QuantLib:
_QuantLib.FdmStepCondition_swigregister(FdmStepCondition)

class FdmStepConditionProxy(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        _QuantLib.FdmStepConditionProxy_swiginit(self, _QuantLib.new_FdmStepConditionProxy(callback))
    __swig_destroy__ = _QuantLib.delete_FdmStepConditionProxy

# Register FdmStepConditionProxy in _QuantLib:
_QuantLib.FdmStepConditionProxy_swigregister(FdmStepConditionProxy)

class FdmInnerValueCalculator(object):
    thisown = 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 innerValue(self, iter, t):
        return _QuantLib.FdmInnerValueCalculator_innerValue(self, iter, t)

    def avgInnerValue(self, iter, t):
        return _QuantLib.FdmInnerValueCalculator_avgInnerValue(self, iter, t)
    __swig_destroy__ = _QuantLib.delete_FdmInnerValueCalculator

# Register FdmInnerValueCalculator in _QuantLib:
_QuantLib.FdmInnerValueCalculator_swigregister(FdmInnerValueCalculator)

class FdmInnerValueCalculatorProxy(FdmInnerValueCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, callback):
        _QuantLib.FdmInnerValueCalculatorProxy_swiginit(self, _QuantLib.new_FdmInnerValueCalculatorProxy(callback))
    __swig_destroy__ = _QuantLib.delete_FdmInnerValueCalculatorProxy

# Register FdmInnerValueCalculatorProxy in _QuantLib:
_QuantLib.FdmInnerValueCalculatorProxy_swigregister(FdmInnerValueCalculatorProxy)

class FdmCellAveragingInnerValue(FdmInnerValueCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmCellAveragingInnerValue_swiginit(self, _QuantLib.new_FdmCellAveragingInnerValue(*args))
    __swig_destroy__ = _QuantLib.delete_FdmCellAveragingInnerValue

# Register FdmCellAveragingInnerValue in _QuantLib:
_QuantLib.FdmCellAveragingInnerValue_swigregister(FdmCellAveragingInnerValue)

class FdmLogInnerValue(FdmCellAveragingInnerValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, mesher, direction):
        _QuantLib.FdmLogInnerValue_swiginit(self, _QuantLib.new_FdmLogInnerValue(payoff, mesher, direction))
    __swig_destroy__ = _QuantLib.delete_FdmLogInnerValue

# Register FdmLogInnerValue in _QuantLib:
_QuantLib.FdmLogInnerValue_swigregister(FdmLogInnerValue)

class FdmLogBasketInnerValue(FdmInnerValueCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, payoff, mesher):
        _QuantLib.FdmLogBasketInnerValue_swiginit(self, _QuantLib.new_FdmLogBasketInnerValue(payoff, mesher))
    __swig_destroy__ = _QuantLib.delete_FdmLogBasketInnerValue

# Register FdmLogBasketInnerValue in _QuantLib:
_QuantLib.FdmLogBasketInnerValue_swigregister(FdmLogBasketInnerValue)

class FdmZeroInnerValue(FdmInnerValueCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _QuantLib.FdmZeroInnerValue_swiginit(self, _QuantLib.new_FdmZeroInnerValue())
    __swig_destroy__ = _QuantLib.delete_FdmZeroInnerValue

# Register FdmZeroInnerValue in _QuantLib:
_QuantLib.FdmZeroInnerValue_swigregister(FdmZeroInnerValue)

class TimeToDateMap(object):
    thisown = 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.TimeToDateMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.TimeToDateMap___nonzero__(self)

    def __bool__(self):
        return _QuantLib.TimeToDateMap___bool__(self)

    def __len__(self):
        return _QuantLib.TimeToDateMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _QuantLib.TimeToDateMap___getitem__(self, key)

    def __delitem__(self, key):
        return _QuantLib.TimeToDateMap___delitem__(self, key)

    def has_key(self, key):
        return _QuantLib.TimeToDateMap_has_key(self, key)

    def keys(self):
        return _QuantLib.TimeToDateMap_keys(self)

    def values(self):
        return _QuantLib.TimeToDateMap_values(self)

    def items(self):
        return _QuantLib.TimeToDateMap_items(self)

    def __contains__(self, key):
        return _QuantLib.TimeToDateMap___contains__(self, key)

    def key_iterator(self):
        return _QuantLib.TimeToDateMap_key_iterator(self)

    def value_iterator(self):
        return _QuantLib.TimeToDateMap_value_iterator(self)

    def __setitem__(self, *args):
        return _QuantLib.TimeToDateMap___setitem__(self, *args)

    def asdict(self):
        return _QuantLib.TimeToDateMap_asdict(self)

    def __init__(self, *args):
        _QuantLib.TimeToDateMap_swiginit(self, _QuantLib.new_TimeToDateMap(*args))

    def empty(self):
        return _QuantLib.TimeToDateMap_empty(self)

    def size(self):
        return _QuantLib.TimeToDateMap_size(self)

    def swap(self, v):
        return _QuantLib.TimeToDateMap_swap(self, v)

    def begin(self):
        return _QuantLib.TimeToDateMap_begin(self)

    def end(self):
        return _QuantLib.TimeToDateMap_end(self)

    def rbegin(self):
        return _QuantLib.TimeToDateMap_rbegin(self)

    def rend(self):
        return _QuantLib.TimeToDateMap_rend(self)

    def clear(self):
        return _QuantLib.TimeToDateMap_clear(self)

    def get_allocator(self):
        return _QuantLib.TimeToDateMap_get_allocator(self)

    def count(self, x):
        return _QuantLib.TimeToDateMap_count(self, x)

    def erase(self, *args):
        return _QuantLib.TimeToDateMap_erase(self, *args)

    def find(self, x):
        return _QuantLib.TimeToDateMap_find(self, x)

    def lower_bound(self, x):
        return _QuantLib.TimeToDateMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _QuantLib.TimeToDateMap_upper_bound(self, x)
    __swig_destroy__ = _QuantLib.delete_TimeToDateMap

# Register TimeToDateMap in _QuantLib:
_QuantLib.TimeToDateMap_swigregister(TimeToDateMap)

class FdmAffineG2ModelSwapInnerValue(FdmInnerValueCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, disModel, fwdModel, swap, exerciseDates, mesher, direction):
        _QuantLib.FdmAffineG2ModelSwapInnerValue_swiginit(self, _QuantLib.new_FdmAffineG2ModelSwapInnerValue(disModel, fwdModel, swap, exerciseDates, mesher, direction))
    __swig_destroy__ = _QuantLib.delete_FdmAffineG2ModelSwapInnerValue

# Register FdmAffineG2ModelSwapInnerValue in _QuantLib:
_QuantLib.FdmAffineG2ModelSwapInnerValue_swigregister(FdmAffineG2ModelSwapInnerValue)

class FdmAffineHullWhiteModelSwapInnerValue(FdmInnerValueCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, disModel, fwdModel, swap, exerciseDates, mesher, direction):
        _QuantLib.FdmAffineHullWhiteModelSwapInnerValue_swiginit(self, _QuantLib.new_FdmAffineHullWhiteModelSwapInnerValue(disModel, fwdModel, swap, exerciseDates, mesher, direction))
    __swig_destroy__ = _QuantLib.delete_FdmAffineHullWhiteModelSwapInnerValue

# Register FdmAffineHullWhiteModelSwapInnerValue in _QuantLib:
_QuantLib.FdmAffineHullWhiteModelSwapInnerValue_swigregister(FdmAffineHullWhiteModelSwapInnerValue)

class FdmSnapshotCondition(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, t):
        _QuantLib.FdmSnapshotCondition_swiginit(self, _QuantLib.new_FdmSnapshotCondition(t))

    def getTime(self):
        return _QuantLib.FdmSnapshotCondition_getTime(self)

    def getValues(self):
        return _QuantLib.FdmSnapshotCondition_getValues(self)
    __swig_destroy__ = _QuantLib.delete_FdmSnapshotCondition

# Register FdmSnapshotCondition in _QuantLib:
_QuantLib.FdmSnapshotCondition_swigregister(FdmSnapshotCondition)

class FdmStepConditionVector(object):
    thisown = 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.FdmStepConditionVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _QuantLib.FdmStepConditionVector___nonzero__(self)

    def __bool__(self):
        return _QuantLib.FdmStepConditionVector___bool__(self)

    def __len__(self):
        return _QuantLib.FdmStepConditionVector___len__(self)

    def __getslice__(self, i, j):
        return _QuantLib.FdmStepConditionVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _QuantLib.FdmStepConditionVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _QuantLib.FdmStepConditionVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _QuantLib.FdmStepConditionVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _QuantLib.FdmStepConditionVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _QuantLib.FdmStepConditionVector___setitem__(self, *args)

    def pop(self):
        return _QuantLib.FdmStepConditionVector_pop(self)

    def append(self, x):
        return _QuantLib.FdmStepConditionVector_append(self, x)

    def empty(self):
        return _QuantLib.FdmStepConditionVector_empty(self)

    def size(self):
        return _QuantLib.FdmStepConditionVector_size(self)

    def swap(self, v):
        return _QuantLib.FdmStepConditionVector_swap(self, v)

    def begin(self):
        return _QuantLib.FdmStepConditionVector_begin(self)

    def end(self):
        return _QuantLib.FdmStepConditionVector_end(self)

    def rbegin(self):
        return _QuantLib.FdmStepConditionVector_rbegin(self)

    def rend(self):
        return _QuantLib.FdmStepConditionVector_rend(self)

    def clear(self):
        return _QuantLib.FdmStepConditionVector_clear(self)

    def get_allocator(self):
        return _QuantLib.FdmStepConditionVector_get_allocator(self)

    def pop_back(self):
        return _QuantLib.FdmStepConditionVector_pop_back(self)

    def erase(self, *args):
        return _QuantLib.FdmStepConditionVector_erase(self, *args)

    def __init__(self, *args):
        _QuantLib.FdmStepConditionVector_swiginit(self, _QuantLib.new_FdmStepConditionVector(*args))

    def push_back(self, x):
        return _QuantLib.FdmStepConditionVector_push_back(self, x)

    def front(self):
        return _QuantLib.FdmStepConditionVector_front(self)

    def back(self):
        return _QuantLib.FdmStepConditionVector_back(self)

    def assign(self, n, x):
        return _QuantLib.FdmStepConditionVector_assign(self, n, x)

    def resize(self, *args):
        return _QuantLib.FdmStepConditionVector_resize(self, *args)

    def insert(self, *args):
        return _QuantLib.FdmStepConditionVector_insert(self, *args)

    def reserve(self, n):
        return _QuantLib.FdmStepConditionVector_reserve(self, n)

    def capacity(self):
        return _QuantLib.FdmStepConditionVector_capacity(self)
    __swig_destroy__ = _QuantLib.delete_FdmStepConditionVector

# Register FdmStepConditionVector in _QuantLib:
_QuantLib.FdmStepConditionVector_swigregister(FdmStepConditionVector)

class FdmStepConditionComposite(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, stoppingTimes, conditions):
        _QuantLib.FdmStepConditionComposite_swiginit(self, _QuantLib.new_FdmStepConditionComposite(stoppingTimes, conditions))

    def stoppingTimes(self):
        return _QuantLib.FdmStepConditionComposite_stoppingTimes(self)

    def conditions(self):
        return _QuantLib.FdmStepConditionComposite_conditions(self)

    @staticmethod
    def joinConditions(c1, c2):
        return _QuantLib.FdmStepConditionComposite_joinConditions(c1, c2)

    @staticmethod
    def vanillaComposite(schedule, exercise, mesher, calculator, refDate, dayCounter):
        return _QuantLib.FdmStepConditionComposite_vanillaComposite(schedule, exercise, mesher, calculator, refDate, dayCounter)
    __swig_destroy__ = _QuantLib.delete_FdmStepConditionComposite

# Register FdmStepConditionComposite in _QuantLib:
_QuantLib.FdmStepConditionComposite_swigregister(FdmStepConditionComposite)

def FdmStepConditionComposite_joinConditions(c1, c2):
    return _QuantLib.FdmStepConditionComposite_joinConditions(c1, c2)

def FdmStepConditionComposite_vanillaComposite(schedule, exercise, mesher, calculator, refDate, dayCounter):
    return _QuantLib.FdmStepConditionComposite_vanillaComposite(schedule, exercise, mesher, calculator, refDate, dayCounter)

class FdmAmericanStepCondition(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, calculator):
        _QuantLib.FdmAmericanStepCondition_swiginit(self, _QuantLib.new_FdmAmericanStepCondition(mesher, calculator))
    __swig_destroy__ = _QuantLib.delete_FdmAmericanStepCondition

# Register FdmAmericanStepCondition in _QuantLib:
_QuantLib.FdmAmericanStepCondition_swigregister(FdmAmericanStepCondition)

class FdmArithmeticAverageCondition(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, averageTimes, arg3, pastFixings, mesher, equityDirection):
        _QuantLib.FdmArithmeticAverageCondition_swiginit(self, _QuantLib.new_FdmArithmeticAverageCondition(averageTimes, arg3, pastFixings, mesher, equityDirection))
    __swig_destroy__ = _QuantLib.delete_FdmArithmeticAverageCondition

# Register FdmArithmeticAverageCondition in _QuantLib:
_QuantLib.FdmArithmeticAverageCondition_swigregister(FdmArithmeticAverageCondition)

class FdmBermudanStepCondition(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exerciseDates, referenceDate, dayCounter, mesher, calculator):
        _QuantLib.FdmBermudanStepCondition_swiginit(self, _QuantLib.new_FdmBermudanStepCondition(exerciseDates, referenceDate, dayCounter, mesher, calculator))

    def exerciseTimes(self):
        return _QuantLib.FdmBermudanStepCondition_exerciseTimes(self)
    __swig_destroy__ = _QuantLib.delete_FdmBermudanStepCondition

# Register FdmBermudanStepCondition in _QuantLib:
_QuantLib.FdmBermudanStepCondition_swigregister(FdmBermudanStepCondition)

class FdmSimpleStorageCondition(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exerciseTimes, mesher, calculator, changeRate):
        _QuantLib.FdmSimpleStorageCondition_swiginit(self, _QuantLib.new_FdmSimpleStorageCondition(exerciseTimes, mesher, calculator, changeRate))
    __swig_destroy__ = _QuantLib.delete_FdmSimpleStorageCondition

# Register FdmSimpleStorageCondition in _QuantLib:
_QuantLib.FdmSimpleStorageCondition_swigregister(FdmSimpleStorageCondition)

class FdmSimpleSwingCondition(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, exerciseTimes, mesher, calculator, swingDirection, minExercises=0):
        _QuantLib.FdmSimpleSwingCondition_swiginit(self, _QuantLib.new_FdmSimpleSwingCondition(exerciseTimes, mesher, calculator, swingDirection, minExercises))
    __swig_destroy__ = _QuantLib.delete_FdmSimpleSwingCondition

# Register FdmSimpleSwingCondition in _QuantLib:
_QuantLib.FdmSimpleSwingCondition_swigregister(FdmSimpleSwingCondition)

class FdmDividendHandler(FdmStepCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, schedule, mesher, referenceDate, dayCounter, equityDirection):
        _QuantLib.FdmDividendHandler_swiginit(self, _QuantLib.new_FdmDividendHandler(schedule, mesher, referenceDate, dayCounter, equityDirection))

    def dividendTimes(self):
        return _QuantLib.FdmDividendHandler_dividendTimes(self)

    def dividendDates(self):
        return _QuantLib.FdmDividendHandler_dividendDates(self)

    def dividends(self):
        return _QuantLib.FdmDividendHandler_dividends(self)
    __swig_destroy__ = _QuantLib.delete_FdmDividendHandler

# Register FdmDividendHandler in _QuantLib:
_QuantLib.FdmDividendHandler_swigregister(FdmDividendHandler)

class FdmSolverDesc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mesher, bcSet, condition, calculator, maturity, timeSteps, dampingSteps):
        _QuantLib.FdmSolverDesc_swiginit(self, _QuantLib.new_FdmSolverDesc(mesher, bcSet, condition, calculator, maturity, timeSteps, dampingSteps))

    def getMesher(self):
        return _QuantLib.FdmSolverDesc_getMesher(self)

    def getBcSet(self):
        return _QuantLib.FdmSolverDesc_getBcSet(self)

    def getStepConditions(self):
        return _QuantLib.FdmSolverDesc_getStepConditions(self)

    def getCalculator(self):
        return _QuantLib.FdmSolverDesc_getCalculator(self)

    def getMaturity(self):
        return _QuantLib.FdmSolverDesc_getMaturity(self)

    def getTimeSteps(self):
        return _QuantLib.FdmSolverDesc_getTimeSteps(self)

    def getDampingSteps(self):
        return _QuantLib.FdmSolverDesc_getDampingSteps(self)
    __swig_destroy__ = _QuantLib.delete_FdmSolverDesc

# Register FdmSolverDesc in _QuantLib:
_QuantLib.FdmSolverDesc_swigregister(FdmSolverDesc)

class Fdm1DimSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        _QuantLib.Fdm1DimSolver_swiginit(self, _QuantLib.new_Fdm1DimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        return _QuantLib.Fdm1DimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        return _QuantLib.Fdm1DimSolver_thetaAt(self, x)

    def derivativeX(self, x):
        return _QuantLib.Fdm1DimSolver_derivativeX(self, x)

    def derivativeXX(self, x):
        return _QuantLib.Fdm1DimSolver_derivativeXX(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm1DimSolver

# Register Fdm1DimSolver in _QuantLib:
_QuantLib.Fdm1DimSolver_swigregister(Fdm1DimSolver)

class FdmBackwardSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, map, bcSet, condition, schemeDesc):
        _QuantLib.FdmBackwardSolver_swiginit(self, _QuantLib.new_FdmBackwardSolver(map, bcSet, condition, schemeDesc))

    def rollback(self, a, _from, to, steps, dampingSteps):
        return _QuantLib.FdmBackwardSolver_rollback(self, a, _from, to, steps, dampingSteps)
    __swig_destroy__ = _QuantLib.delete_FdmBackwardSolver

# Register FdmBackwardSolver in _QuantLib:
_QuantLib.FdmBackwardSolver_swigregister(FdmBackwardSolver)

class Fdm2dBlackScholesSolver(object):
    thisown = 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):
        _QuantLib.Fdm2dBlackScholesSolver_swiginit(self, _QuantLib.new_Fdm2dBlackScholesSolver(*args, **kwargs))

    def valueAt(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_valueAt(self, x, y)

    def thetaAt(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_thetaAt(self, x, y)

    def deltaXat(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_deltaXat(self, x, y)

    def deltaYat(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_deltaYat(self, x, y)

    def gammaXat(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_gammaXat(self, x, y)

    def gammaYat(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_gammaYat(self, x, y)

    def gammaXYat(self, x, y):
        return _QuantLib.Fdm2dBlackScholesSolver_gammaXYat(self, x, y)
    __swig_destroy__ = _QuantLib.delete_Fdm2dBlackScholesSolver

# Register Fdm2dBlackScholesSolver in _QuantLib:
_QuantLib.Fdm2dBlackScholesSolver_swigregister(Fdm2dBlackScholesSolver)

class Fdm2DimSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        _QuantLib.Fdm2DimSolver_swiginit(self, _QuantLib.new_Fdm2DimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x, y):
        return _QuantLib.Fdm2DimSolver_interpolateAt(self, x, y)

    def thetaAt(self, x, y):
        return _QuantLib.Fdm2DimSolver_thetaAt(self, x, y)

    def derivativeX(self, x, y):
        return _QuantLib.Fdm2DimSolver_derivativeX(self, x, y)

    def derivativeY(self, x, y):
        return _QuantLib.Fdm2DimSolver_derivativeY(self, x, y)

    def derivativeXX(self, x, y):
        return _QuantLib.Fdm2DimSolver_derivativeXX(self, x, y)

    def derivativeYY(self, x, y):
        return _QuantLib.Fdm2DimSolver_derivativeYY(self, x, y)

    def derivativeXY(self, x, y):
        return _QuantLib.Fdm2DimSolver_derivativeXY(self, x, y)
    __swig_destroy__ = _QuantLib.delete_Fdm2DimSolver

# Register Fdm2DimSolver in _QuantLib:
_QuantLib.Fdm2DimSolver_swigregister(Fdm2DimSolver)

class Fdm3DimSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        _QuantLib.Fdm3DimSolver_swiginit(self, _QuantLib.new_Fdm3DimSolver(solverDesc, schemeDesc, op))

    def performCalculations(self):
        return _QuantLib.Fdm3DimSolver_performCalculations(self)

    def interpolateAt(self, x, y, z):
        return _QuantLib.Fdm3DimSolver_interpolateAt(self, x, y, z)

    def thetaAt(self, x, y, z):
        return _QuantLib.Fdm3DimSolver_thetaAt(self, x, y, z)
    __swig_destroy__ = _QuantLib.delete_Fdm3DimSolver

# Register Fdm3DimSolver in _QuantLib:
_QuantLib.Fdm3DimSolver_swigregister(Fdm3DimSolver)

class FdmG2Solver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmG2Solver_swiginit(self, _QuantLib.new_FdmG2Solver(*args))

    def valueAt(self, x, y):
        return _QuantLib.FdmG2Solver_valueAt(self, x, y)
    __swig_destroy__ = _QuantLib.delete_FdmG2Solver

# Register FdmG2Solver in _QuantLib:
_QuantLib.FdmG2Solver_swigregister(FdmG2Solver)

class FdmHestonHullWhiteSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmHestonHullWhiteSolver_swiginit(self, _QuantLib.new_FdmHestonHullWhiteSolver(*args))

    def valueAt(self, s, v, r):
        return _QuantLib.FdmHestonHullWhiteSolver_valueAt(self, s, v, r)

    def thetaAt(self, s, v, r):
        return _QuantLib.FdmHestonHullWhiteSolver_thetaAt(self, s, v, r)

    def deltaAt(self, s, v, r, eps):
        return _QuantLib.FdmHestonHullWhiteSolver_deltaAt(self, s, v, r, eps)

    def gammaAt(self, s, v, r, eps):
        return _QuantLib.FdmHestonHullWhiteSolver_gammaAt(self, s, v, r, eps)
    __swig_destroy__ = _QuantLib.delete_FdmHestonHullWhiteSolver

# Register FdmHestonHullWhiteSolver in _QuantLib:
_QuantLib.FdmHestonHullWhiteSolver_swigregister(FdmHestonHullWhiteSolver)

class FdmHestonSolver(object):
    thisown = 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):
        _QuantLib.FdmHestonSolver_swiginit(self, _QuantLib.new_FdmHestonSolver(*args, **kwargs))

    def valueAt(self, s, v):
        return _QuantLib.FdmHestonSolver_valueAt(self, s, v)

    def thetaAt(self, s, v):
        return _QuantLib.FdmHestonSolver_thetaAt(self, s, v)

    def deltaAt(self, s, v):
        return _QuantLib.FdmHestonSolver_deltaAt(self, s, v)

    def gammaAt(self, s, v):
        return _QuantLib.FdmHestonSolver_gammaAt(self, s, v)

    def meanVarianceDeltaAt(self, s, v):
        return _QuantLib.FdmHestonSolver_meanVarianceDeltaAt(self, s, v)

    def meanVarianceGammaAt(self, s, v):
        return _QuantLib.FdmHestonSolver_meanVarianceGammaAt(self, s, v)
    __swig_destroy__ = _QuantLib.delete_FdmHestonSolver

# Register FdmHestonSolver in _QuantLib:
_QuantLib.FdmHestonSolver_swigregister(FdmHestonSolver)

class FdmHullWhiteSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FdmHullWhiteSolver_swiginit(self, _QuantLib.new_FdmHullWhiteSolver(*args))

    def valueAt(self, r):
        return _QuantLib.FdmHullWhiteSolver_valueAt(self, r)
    __swig_destroy__ = _QuantLib.delete_FdmHullWhiteSolver

# Register FdmHullWhiteSolver in _QuantLib:
_QuantLib.FdmHullWhiteSolver_swigregister(FdmHullWhiteSolver)

class Fdm4dimSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        _QuantLib.Fdm4dimSolver_swiginit(self, _QuantLib.new_Fdm4dimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        return _QuantLib.Fdm4dimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        return _QuantLib.Fdm4dimSolver_thetaAt(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm4dimSolver

# Register Fdm4dimSolver in _QuantLib:
_QuantLib.Fdm4dimSolver_swigregister(Fdm4dimSolver)

class Fdm5dimSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        _QuantLib.Fdm5dimSolver_swiginit(self, _QuantLib.new_Fdm5dimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        return _QuantLib.Fdm5dimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        return _QuantLib.Fdm5dimSolver_thetaAt(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm5dimSolver

# Register Fdm5dimSolver in _QuantLib:
_QuantLib.Fdm5dimSolver_swigregister(Fdm5dimSolver)

class Fdm6dimSolver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, solverDesc, schemeDesc, op):
        _QuantLib.Fdm6dimSolver_swiginit(self, _QuantLib.new_Fdm6dimSolver(solverDesc, schemeDesc, op))

    def interpolateAt(self, x):
        return _QuantLib.Fdm6dimSolver_interpolateAt(self, x)

    def thetaAt(self, x):
        return _QuantLib.Fdm6dimSolver_thetaAt(self, x)
    __swig_destroy__ = _QuantLib.delete_Fdm6dimSolver

# Register Fdm6dimSolver in _QuantLib:
_QuantLib.Fdm6dimSolver_swigregister(Fdm6dimSolver)

class FdmIndicesOnBoundary(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, l, direction, side):
        _QuantLib.FdmIndicesOnBoundary_swiginit(self, _QuantLib.new_FdmIndicesOnBoundary(l, direction, side))

    def getIndices(self):
        return _QuantLib.FdmIndicesOnBoundary_getIndices(self)
    __swig_destroy__ = _QuantLib.delete_FdmIndicesOnBoundary

# Register FdmIndicesOnBoundary in _QuantLib:
_QuantLib.FdmIndicesOnBoundary_swigregister(FdmIndicesOnBoundary)

class RiskNeutralDensityCalculator(object):
    thisown = 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 pdf(self, x, t):
        return _QuantLib.RiskNeutralDensityCalculator_pdf(self, x, t)

    def cdf(self, x, t):
        return _QuantLib.RiskNeutralDensityCalculator_cdf(self, x, t)

    def invcdf(self, p, t):
        return _QuantLib.RiskNeutralDensityCalculator_invcdf(self, p, t)
    __swig_destroy__ = _QuantLib.delete_RiskNeutralDensityCalculator

# Register RiskNeutralDensityCalculator in _QuantLib:
_QuantLib.RiskNeutralDensityCalculator_swigregister(RiskNeutralDensityCalculator)

class BSMRNDCalculator(RiskNeutralDensityCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.BSMRNDCalculator_swiginit(self, _QuantLib.new_BSMRNDCalculator(process))
    __swig_destroy__ = _QuantLib.delete_BSMRNDCalculator

# Register BSMRNDCalculator in _QuantLib:
_QuantLib.BSMRNDCalculator_swigregister(BSMRNDCalculator)

class CEVRNDCalculator(RiskNeutralDensityCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, f0, alpha, beta):
        _QuantLib.CEVRNDCalculator_swiginit(self, _QuantLib.new_CEVRNDCalculator(f0, alpha, beta))

    def massAtZero(self, t):
        return _QuantLib.CEVRNDCalculator_massAtZero(self, t)
    __swig_destroy__ = _QuantLib.delete_CEVRNDCalculator

# Register CEVRNDCalculator in _QuantLib:
_QuantLib.CEVRNDCalculator_swigregister(CEVRNDCalculator)

class GBSMRNDCalculator(RiskNeutralDensityCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process):
        _QuantLib.GBSMRNDCalculator_swiginit(self, _QuantLib.new_GBSMRNDCalculator(process))
    __swig_destroy__ = _QuantLib.delete_GBSMRNDCalculator

# Register GBSMRNDCalculator in _QuantLib:
_QuantLib.GBSMRNDCalculator_swigregister(GBSMRNDCalculator)

class HestonRNDCalculator(RiskNeutralDensityCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, hestonProcess, integrationEps=1e-6, maxIntegrationIterations=10000):
        _QuantLib.HestonRNDCalculator_swiginit(self, _QuantLib.new_HestonRNDCalculator(hestonProcess, integrationEps, maxIntegrationIterations))
    __swig_destroy__ = _QuantLib.delete_HestonRNDCalculator

# Register HestonRNDCalculator in _QuantLib:
_QuantLib.HestonRNDCalculator_swigregister(HestonRNDCalculator)

class LocalVolRNDCalculator(RiskNeutralDensityCalculator):
    thisown = 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):
        _QuantLib.LocalVolRNDCalculator_swiginit(self, _QuantLib.new_LocalVolRNDCalculator(*args, **kwargs))

    def mesher(self, t):
        return _QuantLib.LocalVolRNDCalculator_mesher(self, t)

    def rescaleTimeSteps(self):
        return _QuantLib.LocalVolRNDCalculator_rescaleTimeSteps(self)
    __swig_destroy__ = _QuantLib.delete_LocalVolRNDCalculator

# Register LocalVolRNDCalculator in _QuantLib:
_QuantLib.LocalVolRNDCalculator_swigregister(LocalVolRNDCalculator)

class SquareRootProcessRNDCalculator(RiskNeutralDensityCalculator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, v0, kappa, theta, sigma):
        _QuantLib.SquareRootProcessRNDCalculator_swiginit(self, _QuantLib.new_SquareRootProcessRNDCalculator(v0, kappa, theta, sigma))

    def stationary_pdf(self, v):
        return _QuantLib.SquareRootProcessRNDCalculator_stationary_pdf(self, v)

    def stationary_cdf(self, v):
        return _QuantLib.SquareRootProcessRNDCalculator_stationary_cdf(self, v)

    def stationary_invcdf(self, q):
        return _QuantLib.SquareRootProcessRNDCalculator_stationary_invcdf(self, q)
    __swig_destroy__ = _QuantLib.delete_SquareRootProcessRNDCalculator

# Register SquareRootProcessRNDCalculator in _QuantLib:
_QuantLib.SquareRootProcessRNDCalculator_swigregister(SquareRootProcessRNDCalculator)

class FittingMethod(object):
    thisown = 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_FittingMethod

    def size(self):
        return _QuantLib.FittingMethod_size(self)

    def solution(self):
        return _QuantLib.FittingMethod_solution(self)

    def numberOfIterations(self):
        return _QuantLib.FittingMethod_numberOfIterations(self)

    def minimumCostValue(self):
        return _QuantLib.FittingMethod_minimumCostValue(self)

    def constrainAtZero(self):
        return _QuantLib.FittingMethod_constrainAtZero(self)

    def weights(self):
        return _QuantLib.FittingMethod_weights(self)

# Register FittingMethod in _QuantLib:
_QuantLib.FittingMethod_swigregister(FittingMethod)

class FittedBondDiscountCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FittedBondDiscountCurve_swiginit(self, _QuantLib.new_FittedBondDiscountCurve(*args))

    def fitResults(self):
        return _QuantLib.FittedBondDiscountCurve_fitResults(self)
    __swig_destroy__ = _QuantLib.delete_FittedBondDiscountCurve

# Register FittedBondDiscountCurve in _QuantLib:
_QuantLib.FittedBondDiscountCurve_swigregister(FittedBondDiscountCurve)

class ExponentialSplinesFitting(FittingMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ExponentialSplinesFitting_swiginit(self, _QuantLib.new_ExponentialSplinesFitting(*args))
    __swig_destroy__ = _QuantLib.delete_ExponentialSplinesFitting

# Register ExponentialSplinesFitting in _QuantLib:
_QuantLib.ExponentialSplinesFitting_swigregister(ExponentialSplinesFitting)

class NelsonSiegelFitting(FittingMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NelsonSiegelFitting_swiginit(self, _QuantLib.new_NelsonSiegelFitting(*args))
    __swig_destroy__ = _QuantLib.delete_NelsonSiegelFitting

# Register NelsonSiegelFitting in _QuantLib:
_QuantLib.NelsonSiegelFitting_swigregister(NelsonSiegelFitting)

class SvenssonFitting(FittingMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SvenssonFitting_swiginit(self, _QuantLib.new_SvenssonFitting(*args))
    __swig_destroy__ = _QuantLib.delete_SvenssonFitting

# Register SvenssonFitting in _QuantLib:
_QuantLib.SvenssonFitting_swigregister(SvenssonFitting)

class CubicBSplinesFitting(FittingMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CubicBSplinesFitting_swiginit(self, _QuantLib.new_CubicBSplinesFitting(*args))

    def basisFunction(self, i, t):
        return _QuantLib.CubicBSplinesFitting_basisFunction(self, i, t)
    __swig_destroy__ = _QuantLib.delete_CubicBSplinesFitting

# Register CubicBSplinesFitting in _QuantLib:
_QuantLib.CubicBSplinesFitting_swigregister(CubicBSplinesFitting)

class SimplePolynomialFitting(FittingMethod):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SimplePolynomialFitting_swiginit(self, _QuantLib.new_SimplePolynomialFitting(*args))
    __swig_destroy__ = _QuantLib.delete_SimplePolynomialFitting

# Register SimplePolynomialFitting in _QuantLib:
_QuantLib.SimplePolynomialFitting_swigregister(SimplePolynomialFitting)

class ForwardCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ForwardCurve_swiginit(self, _QuantLib.new_ForwardCurve(*args))

    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

# Register ForwardCurve in _QuantLib:
_QuantLib.ForwardCurve_swigregister(ForwardCurve)

class Forward(Instrument):
    thisown = 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 settlementDate(self):
        return _QuantLib.Forward_settlementDate(self)

    def isExpired(self):
        return _QuantLib.Forward_isExpired(self)

    def calendar(self):
        return _QuantLib.Forward_calendar(self)

    def businessDayConvention(self):
        return _QuantLib.Forward_businessDayConvention(self)

    def dayCounter(self):
        return _QuantLib.Forward_dayCounter(self)

    def discountCurve(self):
        return _QuantLib.Forward_discountCurve(self)

    def incomeDiscountCurve(self):
        return _QuantLib.Forward_incomeDiscountCurve(self)

    def spotValue(self):
        return _QuantLib.Forward_spotValue(self)

    def spotIncome(self, incomeDiscountCurve):
        return _QuantLib.Forward_spotIncome(self, incomeDiscountCurve)

    def forwardValue(self):
        return _QuantLib.Forward_forwardValue(self)

    def impliedYield(self, underlyingSpotValue, forwardValue, settlementDate, compoundingConvention, dayCounter):
        return _QuantLib.Forward_impliedYield(self, underlyingSpotValue, forwardValue, settlementDate, compoundingConvention, dayCounter)
    __swig_destroy__ = _QuantLib.delete_Forward

# Register Forward in _QuantLib:
_QuantLib.Forward_swigregister(Forward)

class FixedRateBondForward(Forward):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FixedRateBondForward_swiginit(self, _QuantLib.new_FixedRateBondForward(*args))

    def forwardPrice(self):
        return _QuantLib.FixedRateBondForward_forwardPrice(self)

    def cleanForwardPrice(self):
        return _QuantLib.FixedRateBondForward_cleanForwardPrice(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBondForward

# Register FixedRateBondForward in _QuantLib:
_QuantLib.FixedRateBondForward_swigregister(FixedRateBondForward)

class Position(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Long = _QuantLib.Position_Long
    Short = _QuantLib.Position_Short

    def __init__(self):
        _QuantLib.Position_swiginit(self, _QuantLib.new_Position())
    __swig_destroy__ = _QuantLib.delete_Position

# Register Position in _QuantLib:
_QuantLib.Position_swigregister(Position)

class ForwardRateAgreement(Forward):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ForwardRateAgreement_swiginit(self, _QuantLib.new_ForwardRateAgreement(*args))

    def fixingDate(self):
        return _QuantLib.ForwardRateAgreement_fixingDate(self)

    def spotIncome(self, discount):
        return _QuantLib.ForwardRateAgreement_spotIncome(self, discount)

    def spotValue(self):
        return _QuantLib.ForwardRateAgreement_spotValue(self)

    def forwardRate(self):
        return _QuantLib.ForwardRateAgreement_forwardRate(self)
    __swig_destroy__ = _QuantLib.delete_ForwardRateAgreement

# Register ForwardRateAgreement in _QuantLib:
_QuantLib.ForwardRateAgreement_swigregister(ForwardRateAgreement)

class Gaussian1dModel(TermStructureConsistentModel):
    thisown = 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 stateProcess(self):
        return _QuantLib.Gaussian1dModel_stateProcess(self)

    def numeraire(self, *args):
        return _QuantLib.Gaussian1dModel_numeraire(self, *args)

    def zerobond(self, *args):
        return _QuantLib.Gaussian1dModel_zerobond(self, *args)

    def zerobondOption(self, *args):
        return _QuantLib.Gaussian1dModel_zerobondOption(self, *args)

    def forwardRate(self, *args):
        return _QuantLib.Gaussian1dModel_forwardRate(self, *args)

    def swapRate(self, *args):
        return _QuantLib.Gaussian1dModel_swapRate(self, *args)

    def swapAnnuity(self, *args):
        return _QuantLib.Gaussian1dModel_swapAnnuity(self, *args)
    __swig_destroy__ = _QuantLib.delete_Gaussian1dModel

# Register Gaussian1dModel in _QuantLib:
_QuantLib.Gaussian1dModel_swigregister(Gaussian1dModel)

class Gsr(Gaussian1dModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, termStructure, volstepdates, volatilities, reversions, T=60.0):
        _QuantLib.Gsr_swiginit(self, _QuantLib.new_Gsr(termStructure, volstepdates, volatilities, reversions, T))

    def calibrateVolatilitiesIterative(self, *args):
        return _QuantLib.Gsr_calibrateVolatilitiesIterative(self, *args)

    def reversion(self):
        return _QuantLib.Gsr_reversion(self)

    def volatility(self):
        return _QuantLib.Gsr_volatility(self)

    def params(self):
        return _QuantLib.Gsr_params(self)

    def calibrate(self, *args):
        return _QuantLib.Gsr_calibrate(self, *args)

    def setParams(self, params):
        return _QuantLib.Gsr_setParams(self, params)

    def value(self, params, instruments):
        return _QuantLib.Gsr_value(self, params, instruments)

    def constraint(self):
        return _QuantLib.Gsr_constraint(self)

    def endCriteria(self):
        return _QuantLib.Gsr_endCriteria(self)

    def problemValues(self):
        return _QuantLib.Gsr_problemValues(self)

    def functionEvaluation(self):
        return _QuantLib.Gsr_functionEvaluation(self)
    __swig_destroy__ = _QuantLib.delete_Gsr

# Register Gsr in _QuantLib:
_QuantLib.Gsr_swigregister(Gsr)

class MarkovFunctional(Gaussian1dModel):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MarkovFunctional_swiginit(self, _QuantLib.new_MarkovFunctional(*args))

    def volatility(self):
        return _QuantLib.MarkovFunctional_volatility(self)

    def calibrate(self, *args):
        return _QuantLib.MarkovFunctional_calibrate(self, *args)

    def params(self):
        return _QuantLib.MarkovFunctional_params(self)

    def setParams(self, params):
        return _QuantLib.MarkovFunctional_setParams(self, params)

    def value(self, params, instruments):
        return _QuantLib.MarkovFunctional_value(self, params, instruments)

    def constraint(self):
        return _QuantLib.MarkovFunctional_constraint(self)

    def endCriteria(self):
        return _QuantLib.MarkovFunctional_endCriteria(self)

    def problemValues(self):
        return _QuantLib.MarkovFunctional_problemValues(self)

    def functionEvaluation(self):
        return _QuantLib.MarkovFunctional_functionEvaluation(self)
    __swig_destroy__ = _QuantLib.delete_MarkovFunctional

# Register MarkovFunctional in _QuantLib:
_QuantLib.MarkovFunctional_swigregister(MarkovFunctional)

class MarkovFunctionalSettings(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AdjustNone = _QuantLib.MarkovFunctionalSettings_AdjustNone
    AdjustDigitals = _QuantLib.MarkovFunctionalSettings_AdjustDigitals
    AdjustYts = _QuantLib.MarkovFunctionalSettings_AdjustYts
    ExtrapolatePayoffFlat = _QuantLib.MarkovFunctionalSettings_ExtrapolatePayoffFlat
    NoPayoffExtrapolation = _QuantLib.MarkovFunctionalSettings_NoPayoffExtrapolation
    KahaleSmile = _QuantLib.MarkovFunctionalSettings_KahaleSmile
    SmileExponentialExtrapolation = _QuantLib.MarkovFunctionalSettings_SmileExponentialExtrapolation
    KahaleInterpolation = _QuantLib.MarkovFunctionalSettings_KahaleInterpolation
    SmileDeleteArbitragePoints = _QuantLib.MarkovFunctionalSettings_SmileDeleteArbitragePoints
    SabrSmile = _QuantLib.MarkovFunctionalSettings_SabrSmile

    def __init__(self, *args):
        _QuantLib.MarkovFunctionalSettings_swiginit(self, _QuantLib.new_MarkovFunctionalSettings(*args))

    def validate(self):
        return _QuantLib.MarkovFunctionalSettings_validate(self)
    __swig_destroy__ = _QuantLib.delete_MarkovFunctionalSettings

# Register MarkovFunctionalSettings in _QuantLib:
_QuantLib.MarkovFunctionalSettings_swigregister(MarkovFunctionalSettings)

class Gaussian1dSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoProb = _QuantLib.Gaussian1dSwaptionEngine_NoProb
    Naive = _QuantLib.Gaussian1dSwaptionEngine_Naive
    Digital = _QuantLib.Gaussian1dSwaptionEngine_Digital

    def __init__(self, *args):
        _QuantLib.Gaussian1dSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dSwaptionEngine

# Register Gaussian1dSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dSwaptionEngine_swigregister(Gaussian1dSwaptionEngine)

class Gaussian1dJamshidianSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, model):
        _QuantLib.Gaussian1dJamshidianSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dJamshidianSwaptionEngine(model))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dJamshidianSwaptionEngine

# Register Gaussian1dJamshidianSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dJamshidianSwaptionEngine_swigregister(Gaussian1dJamshidianSwaptionEngine)

class Gaussian1dNonstandardSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoProb = _QuantLib.Gaussian1dNonstandardSwaptionEngine_NoProb
    Naive = _QuantLib.Gaussian1dNonstandardSwaptionEngine_Naive
    Digital = _QuantLib.Gaussian1dNonstandardSwaptionEngine_Digital

    def __init__(self, *args):
        _QuantLib.Gaussian1dNonstandardSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dNonstandardSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dNonstandardSwaptionEngine

# Register Gaussian1dNonstandardSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dNonstandardSwaptionEngine_swigregister(Gaussian1dNonstandardSwaptionEngine)

class Gaussian1dFloatFloatSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NoProb = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_NoProb
    Naive = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_Naive
    Digital = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_Digital

    def __init__(self, *args):
        _QuantLib.Gaussian1dFloatFloatSwaptionEngine_swiginit(self, _QuantLib.new_Gaussian1dFloatFloatSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_Gaussian1dFloatFloatSwaptionEngine

# Register Gaussian1dFloatFloatSwaptionEngine in _QuantLib:
_QuantLib.Gaussian1dFloatFloatSwaptionEngine_swigregister(Gaussian1dFloatFloatSwaptionEngine)

class SegmentIntegral(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, intervals):
        _QuantLib.SegmentIntegral_swiginit(self, _QuantLib.new_SegmentIntegral(intervals))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.SegmentIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_SegmentIntegral

# Register SegmentIntegral in _QuantLib:
_QuantLib.SegmentIntegral_swigregister(SegmentIntegral)

class TrapezoidIntegralDefault(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        _QuantLib.TrapezoidIntegralDefault_swiginit(self, _QuantLib.new_TrapezoidIntegralDefault(accuracy, maxIterations))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.TrapezoidIntegralDefault___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralDefault

# Register TrapezoidIntegralDefault in _QuantLib:
_QuantLib.TrapezoidIntegralDefault_swigregister(TrapezoidIntegralDefault)

class TrapezoidIntegralMidPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        _QuantLib.TrapezoidIntegralMidPoint_swiginit(self, _QuantLib.new_TrapezoidIntegralMidPoint(accuracy, maxIterations))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.TrapezoidIntegralMidPoint___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralMidPoint

# Register TrapezoidIntegralMidPoint in _QuantLib:
_QuantLib.TrapezoidIntegralMidPoint_swigregister(TrapezoidIntegralMidPoint)

class SimpsonIntegral(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        _QuantLib.SimpsonIntegral_swiginit(self, _QuantLib.new_SimpsonIntegral(accuracy, maxIterations))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.SimpsonIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_SimpsonIntegral

# Register SimpsonIntegral in _QuantLib:
_QuantLib.SimpsonIntegral_swigregister(SimpsonIntegral)

class GaussKronrodAdaptive(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GaussKronrodAdaptive_swiginit(self, _QuantLib.new_GaussKronrodAdaptive(*args))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.GaussKronrodAdaptive___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodAdaptive

# Register GaussKronrodAdaptive in _QuantLib:
_QuantLib.GaussKronrodAdaptive_swigregister(GaussKronrodAdaptive)

class GaussKronrodNonAdaptive(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, absoluteAccuracy, maxEvaluations, relativeAccuracy):
        _QuantLib.GaussKronrodNonAdaptive_swiginit(self, _QuantLib.new_GaussKronrodNonAdaptive(absoluteAccuracy, maxEvaluations, relativeAccuracy))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.GaussKronrodNonAdaptive___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodNonAdaptive

# Register GaussKronrodNonAdaptive in _QuantLib:
_QuantLib.GaussKronrodNonAdaptive_swigregister(GaussKronrodNonAdaptive)

class GaussLobattoIntegral(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GaussLobattoIntegral_swiginit(self, _QuantLib.new_GaussLobattoIntegral(*args))

    def __call__(self, pyFunction, a, b):
        return _QuantLib.GaussLobattoIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussLobattoIntegral

# Register GaussLobattoIntegral in _QuantLib:
_QuantLib.GaussLobattoIntegral_swigregister(GaussLobattoIntegral)

class GaussLaguerreIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, s=0.0):
        _QuantLib.GaussLaguerreIntegration_swiginit(self, _QuantLib.new_GaussLaguerreIntegration(n, s))

    def __call__(self, pyFunction):
        return _QuantLib.GaussLaguerreIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussLaguerreIntegration

# Register GaussLaguerreIntegration in _QuantLib:
_QuantLib.GaussLaguerreIntegration_swigregister(GaussLaguerreIntegration)

class GaussHermiteIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, mu=0.0):
        _QuantLib.GaussHermiteIntegration_swiginit(self, _QuantLib.new_GaussHermiteIntegration(n, mu))

    def __call__(self, pyFunction):
        return _QuantLib.GaussHermiteIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussHermiteIntegration

# Register GaussHermiteIntegration in _QuantLib:
_QuantLib.GaussHermiteIntegration_swigregister(GaussHermiteIntegration)

class GaussJacobiIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, alpha, beta):
        _QuantLib.GaussJacobiIntegration_swiginit(self, _QuantLib.new_GaussJacobiIntegration(n, alpha, beta))

    def __call__(self, pyFunction):
        return _QuantLib.GaussJacobiIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussJacobiIntegration

# Register GaussJacobiIntegration in _QuantLib:
_QuantLib.GaussJacobiIntegration_swigregister(GaussJacobiIntegration)

class GaussHyperbolicIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        _QuantLib.GaussHyperbolicIntegration_swiginit(self, _QuantLib.new_GaussHyperbolicIntegration(n))

    def __call__(self, pyFunction):
        return _QuantLib.GaussHyperbolicIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussHyperbolicIntegration

# Register GaussHyperbolicIntegration in _QuantLib:
_QuantLib.GaussHyperbolicIntegration_swigregister(GaussHyperbolicIntegration)

class GaussLegendreIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        _QuantLib.GaussLegendreIntegration_swiginit(self, _QuantLib.new_GaussLegendreIntegration(n))

    def __call__(self, pyFunction):
        return _QuantLib.GaussLegendreIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussLegendreIntegration

# Register GaussLegendreIntegration in _QuantLib:
_QuantLib.GaussLegendreIntegration_swigregister(GaussLegendreIntegration)

class GaussChebyshevIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        _QuantLib.GaussChebyshevIntegration_swiginit(self, _QuantLib.new_GaussChebyshevIntegration(n))

    def __call__(self, pyFunction):
        return _QuantLib.GaussChebyshevIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussChebyshevIntegration

# Register GaussChebyshevIntegration in _QuantLib:
_QuantLib.GaussChebyshevIntegration_swigregister(GaussChebyshevIntegration)

class GaussChebyshev2ndIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n):
        _QuantLib.GaussChebyshev2ndIntegration_swiginit(self, _QuantLib.new_GaussChebyshev2ndIntegration(n))

    def __call__(self, pyFunction):
        return _QuantLib.GaussChebyshev2ndIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussChebyshev2ndIntegration

# Register GaussChebyshev2ndIntegration in _QuantLib:
_QuantLib.GaussChebyshev2ndIntegration_swigregister(GaussChebyshev2ndIntegration)

class GaussGegenbauerIntegration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, n, lambda_parameter):
        _QuantLib.GaussGegenbauerIntegration_swiginit(self, _QuantLib.new_GaussGegenbauerIntegration(n, lambda_parameter))

    def __call__(self, pyFunction):
        return _QuantLib.GaussGegenbauerIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussGegenbauerIntegration

# Register GaussGegenbauerIntegration in _QuantLib:
_QuantLib.GaussGegenbauerIntegration_swigregister(GaussGegenbauerIntegration)

class SampleNumber(object):
    thisown = 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

# Register SampleNumber in _QuantLib:
_QuantLib.SampleNumber_swigregister(SampleNumber)

class SampleArray(object):
    thisown = 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

# Register SampleArray in _QuantLib:
_QuantLib.SampleArray_swigregister(SampleArray)

class SampleRealVector(object):
    thisown = 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

# Register SampleRealVector in _QuantLib:
_QuantLib.SampleRealVector_swigregister(SampleRealVector)

class LecuyerUniformRng(object):
    thisown = 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):
        _QuantLib.LecuyerUniformRng_swiginit(self, _QuantLib.new_LecuyerUniformRng(seed))

    def next(self):
        return _QuantLib.LecuyerUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRng

# Register LecuyerUniformRng in _QuantLib:
_QuantLib.LecuyerUniformRng_swigregister(LecuyerUniformRng)

class KnuthUniformRng(object):
    thisown = 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):
        _QuantLib.KnuthUniformRng_swiginit(self, _QuantLib.new_KnuthUniformRng(seed))

    def next(self):
        return _QuantLib.KnuthUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRng

# Register KnuthUniformRng in _QuantLib:
_QuantLib.KnuthUniformRng_swigregister(KnuthUniformRng)

class MersenneTwisterUniformRng(object):
    thisown = 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):
        _QuantLib.MersenneTwisterUniformRng_swiginit(self, _QuantLib.new_MersenneTwisterUniformRng(seed))

    def next(self):
        return _QuantLib.MersenneTwisterUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRng

# Register MersenneTwisterUniformRng in _QuantLib:
_QuantLib.MersenneTwisterUniformRng_swigregister(MersenneTwisterUniformRng)

class UniformRandomGenerator(object):
    thisown = 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):
        _QuantLib.UniformRandomGenerator_swiginit(self, _QuantLib.new_UniformRandomGenerator(seed))

    def next(self):
        return _QuantLib.UniformRandomGenerator_next(self)

    def nextValue(self):
        return _QuantLib.UniformRandomGenerator_nextValue(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomGenerator

# Register UniformRandomGenerator in _QuantLib:
_QuantLib.UniformRandomGenerator_swigregister(UniformRandomGenerator)

class CentralLimitLecuyerGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.CentralLimitLecuyerGaussianRng_swiginit(self, _QuantLib.new_CentralLimitLecuyerGaussianRng(rng))

    def next(self):
        return _QuantLib.CentralLimitLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitLecuyerGaussianRng

# Register CentralLimitLecuyerGaussianRng in _QuantLib:
_QuantLib.CentralLimitLecuyerGaussianRng_swigregister(CentralLimitLecuyerGaussianRng)

class CentralLimitKnuthGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.CentralLimitKnuthGaussianRng_swiginit(self, _QuantLib.new_CentralLimitKnuthGaussianRng(rng))

    def next(self):
        return _QuantLib.CentralLimitKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitKnuthGaussianRng

# Register CentralLimitKnuthGaussianRng in _QuantLib:
_QuantLib.CentralLimitKnuthGaussianRng_swigregister(CentralLimitKnuthGaussianRng)

class CentralLimitMersenneTwisterGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.CentralLimitMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_CentralLimitMersenneTwisterGaussianRng(rng))

    def next(self):
        return _QuantLib.CentralLimitMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitMersenneTwisterGaussianRng

# Register CentralLimitMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.CentralLimitMersenneTwisterGaussianRng_swigregister(CentralLimitMersenneTwisterGaussianRng)

class BoxMullerLecuyerGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.BoxMullerLecuyerGaussianRng_swiginit(self, _QuantLib.new_BoxMullerLecuyerGaussianRng(rng))

    def next(self):
        return _QuantLib.BoxMullerLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerLecuyerGaussianRng

# Register BoxMullerLecuyerGaussianRng in _QuantLib:
_QuantLib.BoxMullerLecuyerGaussianRng_swigregister(BoxMullerLecuyerGaussianRng)

class BoxMullerKnuthGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.BoxMullerKnuthGaussianRng_swiginit(self, _QuantLib.new_BoxMullerKnuthGaussianRng(rng))

    def next(self):
        return _QuantLib.BoxMullerKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerKnuthGaussianRng

# Register BoxMullerKnuthGaussianRng in _QuantLib:
_QuantLib.BoxMullerKnuthGaussianRng_swigregister(BoxMullerKnuthGaussianRng)

class BoxMullerMersenneTwisterGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.BoxMullerMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_BoxMullerMersenneTwisterGaussianRng(rng))

    def next(self):
        return _QuantLib.BoxMullerMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerMersenneTwisterGaussianRng

# Register BoxMullerMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.BoxMullerMersenneTwisterGaussianRng_swigregister(BoxMullerMersenneTwisterGaussianRng)

class MoroInvCumulativeLecuyerGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.MoroInvCumulativeLecuyerGaussianRng_swiginit(self, _QuantLib.new_MoroInvCumulativeLecuyerGaussianRng(rng))

    def next(self):
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRng

# Register MoroInvCumulativeLecuyerGaussianRng in _QuantLib:
_QuantLib.MoroInvCumulativeLecuyerGaussianRng_swigregister(MoroInvCumulativeLecuyerGaussianRng)

class MoroInvCumulativeKnuthGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.MoroInvCumulativeKnuthGaussianRng_swiginit(self, _QuantLib.new_MoroInvCumulativeKnuthGaussianRng(rng))

    def next(self):
        return _QuantLib.MoroInvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRng

# Register MoroInvCumulativeKnuthGaussianRng in _QuantLib:
_QuantLib.MoroInvCumulativeKnuthGaussianRng_swigregister(MoroInvCumulativeKnuthGaussianRng)

class MoroInvCumulativeMersenneTwisterGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRng(rng))

    def next(self):
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRng

# Register MoroInvCumulativeMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_swigregister(MoroInvCumulativeMersenneTwisterGaussianRng)

class InvCumulativeLecuyerGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.InvCumulativeLecuyerGaussianRng_swiginit(self, _QuantLib.new_InvCumulativeLecuyerGaussianRng(rng))

    def next(self):
        return _QuantLib.InvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRng

# Register InvCumulativeLecuyerGaussianRng in _QuantLib:
_QuantLib.InvCumulativeLecuyerGaussianRng_swigregister(InvCumulativeLecuyerGaussianRng)

class InvCumulativeKnuthGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.InvCumulativeKnuthGaussianRng_swiginit(self, _QuantLib.new_InvCumulativeKnuthGaussianRng(rng))

    def next(self):
        return _QuantLib.InvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRng

# Register InvCumulativeKnuthGaussianRng in _QuantLib:
_QuantLib.InvCumulativeKnuthGaussianRng_swigregister(InvCumulativeKnuthGaussianRng)

class InvCumulativeMersenneTwisterGaussianRng(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.InvCumulativeMersenneTwisterGaussianRng_swiginit(self, _QuantLib.new_InvCumulativeMersenneTwisterGaussianRng(rng))

    def next(self):
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRng

# Register InvCumulativeMersenneTwisterGaussianRng in _QuantLib:
_QuantLib.InvCumulativeMersenneTwisterGaussianRng_swigregister(InvCumulativeMersenneTwisterGaussianRng)

class GaussianRandomGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, rng):
        _QuantLib.GaussianRandomGenerator_swiginit(self, _QuantLib.new_GaussianRandomGenerator(rng))

    def next(self):
        return _QuantLib.GaussianRandomGenerator_next(self)

    def nextValue(self):
        return _QuantLib.GaussianRandomGenerator_nextValue(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomGenerator

# Register GaussianRandomGenerator in _QuantLib:
_QuantLib.GaussianRandomGenerator_swigregister(GaussianRandomGenerator)

class HaltonRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimensionality, seed=0, randomStart=True, randomShift=False):
        _QuantLib.HaltonRsg_swiginit(self, _QuantLib.new_HaltonRsg(dimensionality, seed, randomStart, randomShift))

    def nextSequence(self):
        return _QuantLib.HaltonRsg_nextSequence(self)

    def lastSequence(self):
        return _QuantLib.HaltonRsg_lastSequence(self)

    def dimension(self):
        return _QuantLib.HaltonRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_HaltonRsg

# Register HaltonRsg in _QuantLib:
_QuantLib.HaltonRsg_swigregister(HaltonRsg)

class SobolRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Unit = _QuantLib.SobolRsg_Unit
    Jaeckel = _QuantLib.SobolRsg_Jaeckel
    SobolLevitan = _QuantLib.SobolRsg_SobolLevitan
    SobolLevitanLemieux = _QuantLib.SobolRsg_SobolLevitanLemieux
    JoeKuoD5 = _QuantLib.SobolRsg_JoeKuoD5
    JoeKuoD6 = _QuantLib.SobolRsg_JoeKuoD6
    JoeKuoD7 = _QuantLib.SobolRsg_JoeKuoD7
    Kuo = _QuantLib.SobolRsg_Kuo
    Kuo2 = _QuantLib.SobolRsg_Kuo2
    Kuo3 = _QuantLib.SobolRsg_Kuo3

    def __init__(self, *args):
        _QuantLib.SobolRsg_swiginit(self, _QuantLib.new_SobolRsg(*args))

    def nextSequence(self):
        return _QuantLib.SobolRsg_nextSequence(self)

    def lastSequence(self):
        return _QuantLib.SobolRsg_lastSequence(self)

    def dimension(self):
        return _QuantLib.SobolRsg_dimension(self)

    def skipTo(self, n):
        return _QuantLib.SobolRsg_skipTo(self, n)

    def nextInt32Sequence(self):
        return _QuantLib.SobolRsg_nextInt32Sequence(self)
    __swig_destroy__ = _QuantLib.delete_SobolRsg

# Register SobolRsg in _QuantLib:
_QuantLib.SobolRsg_swigregister(SobolRsg)

class SobolBrownianBridgeRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, factors, steps):
        _QuantLib.SobolBrownianBridgeRsg_swiginit(self, _QuantLib.new_SobolBrownianBridgeRsg(factors, steps))

    def nextSequence(self):
        return _QuantLib.SobolBrownianBridgeRsg_nextSequence(self)

    def lastSequence(self):
        return _QuantLib.SobolBrownianBridgeRsg_lastSequence(self)

    def dimension(self):
        return _QuantLib.SobolBrownianBridgeRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_SobolBrownianBridgeRsg

# Register SobolBrownianBridgeRsg in _QuantLib:
_QuantLib.SobolBrownianBridgeRsg_swigregister(SobolBrownianBridgeRsg)

class LecuyerUniformRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LecuyerUniformRsg_swiginit(self, _QuantLib.new_LecuyerUniformRsg(*args))

    def nextSequence(self):
        return _QuantLib.LecuyerUniformRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.LecuyerUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRsg

# Register LecuyerUniformRsg in _QuantLib:
_QuantLib.LecuyerUniformRsg_swigregister(LecuyerUniformRsg)

class KnuthUniformRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.KnuthUniformRsg_swiginit(self, _QuantLib.new_KnuthUniformRsg(*args))

    def nextSequence(self):
        return _QuantLib.KnuthUniformRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.KnuthUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRsg

# Register KnuthUniformRsg in _QuantLib:
_QuantLib.KnuthUniformRsg_swigregister(KnuthUniformRsg)

class MersenneTwisterUniformRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MersenneTwisterUniformRsg_swiginit(self, _QuantLib.new_MersenneTwisterUniformRsg(*args))

    def nextSequence(self):
        return _QuantLib.MersenneTwisterUniformRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MersenneTwisterUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRsg

# Register MersenneTwisterUniformRsg in _QuantLib:
_QuantLib.MersenneTwisterUniformRsg_swigregister(MersenneTwisterUniformRsg)

class UniformRandomSequenceGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimensionality, rng):
        _QuantLib.UniformRandomSequenceGenerator_swiginit(self, _QuantLib.new_UniformRandomSequenceGenerator(dimensionality, rng))

    def nextSequence(self):
        return _QuantLib.UniformRandomSequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.UniformRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomSequenceGenerator

# Register UniformRandomSequenceGenerator in _QuantLib:
_QuantLib.UniformRandomSequenceGenerator_swigregister(UniformRandomSequenceGenerator)

class UniformLowDiscrepancySequenceGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.UniformLowDiscrepancySequenceGenerator_swiginit(self, _QuantLib.new_UniformLowDiscrepancySequenceGenerator(*args))

    def nextSequence(self):
        return _QuantLib.UniformLowDiscrepancySequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.UniformLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformLowDiscrepancySequenceGenerator

# Register UniformLowDiscrepancySequenceGenerator in _QuantLib:
_QuantLib.UniformLowDiscrepancySequenceGenerator_swigregister(UniformLowDiscrepancySequenceGenerator)

class MoroInvCumulativeLecuyerGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeLecuyerGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRsg

# Register MoroInvCumulativeLecuyerGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeLecuyerGaussianRsg_swigregister(MoroInvCumulativeLecuyerGaussianRsg)

class MoroInvCumulativeKnuthGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MoroInvCumulativeKnuthGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeKnuthGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRsg

# Register MoroInvCumulativeKnuthGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeKnuthGaussianRsg_swigregister(MoroInvCumulativeKnuthGaussianRsg)

class MoroInvCumulativeMersenneTwisterGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRsg

# Register MoroInvCumulativeMersenneTwisterGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister(MoroInvCumulativeMersenneTwisterGaussianRsg)

class MoroInvCumulativeHaltonGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MoroInvCumulativeHaltonGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeHaltonGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeHaltonGaussianRsg

# Register MoroInvCumulativeHaltonGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeHaltonGaussianRsg_swigregister(MoroInvCumulativeHaltonGaussianRsg)

class MoroInvCumulativeSobolGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MoroInvCumulativeSobolGaussianRsg_swiginit(self, _QuantLib.new_MoroInvCumulativeSobolGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeSobolGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeSobolGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeSobolGaussianRsg

# Register MoroInvCumulativeSobolGaussianRsg in _QuantLib:
_QuantLib.MoroInvCumulativeSobolGaussianRsg_swigregister(MoroInvCumulativeSobolGaussianRsg)

class InvCumulativeLecuyerGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InvCumulativeLecuyerGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeLecuyerGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.InvCumulativeLecuyerGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRsg

# Register InvCumulativeLecuyerGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeLecuyerGaussianRsg_swigregister(InvCumulativeLecuyerGaussianRsg)

class InvCumulativeKnuthGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InvCumulativeKnuthGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeKnuthGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.InvCumulativeKnuthGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRsg

# Register InvCumulativeKnuthGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeKnuthGaussianRsg_swigregister(InvCumulativeKnuthGaussianRsg)

class InvCumulativeMersenneTwisterGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeMersenneTwisterGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRsg

# Register InvCumulativeMersenneTwisterGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeMersenneTwisterGaussianRsg_swigregister(InvCumulativeMersenneTwisterGaussianRsg)

class InvCumulativeHaltonGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InvCumulativeHaltonGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeHaltonGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.InvCumulativeHaltonGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeHaltonGaussianRsg

# Register InvCumulativeHaltonGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeHaltonGaussianRsg_swigregister(InvCumulativeHaltonGaussianRsg)

class InvCumulativeSobolGaussianRsg(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InvCumulativeSobolGaussianRsg_swiginit(self, _QuantLib.new_InvCumulativeSobolGaussianRsg(*args))

    def nextSequence(self):
        return _QuantLib.InvCumulativeSobolGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeSobolGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeSobolGaussianRsg

# Register InvCumulativeSobolGaussianRsg in _QuantLib:
_QuantLib.InvCumulativeSobolGaussianRsg_swigregister(InvCumulativeSobolGaussianRsg)

class GaussianRandomSequenceGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        _QuantLib.GaussianRandomSequenceGenerator_swiginit(self, _QuantLib.new_GaussianRandomSequenceGenerator(uniformSequenceGenerator))

    def nextSequence(self):
        return _QuantLib.GaussianRandomSequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.GaussianRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomSequenceGenerator

# Register GaussianRandomSequenceGenerator in _QuantLib:
_QuantLib.GaussianRandomSequenceGenerator_swigregister(GaussianRandomSequenceGenerator)

class GaussianLowDiscrepancySequenceGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, u):
        _QuantLib.GaussianLowDiscrepancySequenceGenerator_swiginit(self, _QuantLib.new_GaussianLowDiscrepancySequenceGenerator(u))

    def nextSequence(self):
        return _QuantLib.GaussianLowDiscrepancySequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.GaussianLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianLowDiscrepancySequenceGenerator

# Register GaussianLowDiscrepancySequenceGenerator in _QuantLib:
_QuantLib.GaussianLowDiscrepancySequenceGenerator_swigregister(GaussianLowDiscrepancySequenceGenerator)


def getCovariance(volatilities, correlations):
    return _QuantLib.getCovariance(volatilities, correlations)
class Path(object):
    thisown = 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, i):
        return _QuantLib.Path_value(self, i)

    def front(self):
        return _QuantLib.Path_front(self)

    def back(self):
        return _QuantLib.Path_back(self)

    def time(self, i):
        return _QuantLib.Path_time(self, i)

    def __getitem__(self, i):
        return _QuantLib.Path___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_Path

# Register Path in _QuantLib:
_QuantLib.Path_swigregister(Path)

class SamplePath(object):
    thisown = 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

# Register SamplePath in _QuantLib:
_QuantLib.SamplePath_swigregister(SamplePath)

class GaussianPathGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GaussianPathGenerator_swiginit(self, _QuantLib.new_GaussianPathGenerator(*args))

    def next(self):
        return _QuantLib.GaussianPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.GaussianPathGenerator_antithetic(self)

    def size(self):
        return _QuantLib.GaussianPathGenerator_size(self)

    def timeGrid(self):
        return _QuantLib.GaussianPathGenerator_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_GaussianPathGenerator

# Register GaussianPathGenerator in _QuantLib:
_QuantLib.GaussianPathGenerator_swigregister(GaussianPathGenerator)

class GaussianSobolPathGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.GaussianSobolPathGenerator_swiginit(self, _QuantLib.new_GaussianSobolPathGenerator(*args))

    def next(self):
        return _QuantLib.GaussianSobolPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.GaussianSobolPathGenerator_antithetic(self)

    def size(self):
        return _QuantLib.GaussianSobolPathGenerator_size(self)

    def timeGrid(self):
        return _QuantLib.GaussianSobolPathGenerator_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_GaussianSobolPathGenerator

# Register GaussianSobolPathGenerator in _QuantLib:
_QuantLib.GaussianSobolPathGenerator_swigregister(GaussianSobolPathGenerator)

class InvCumulativeMersenneTwisterPathGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.InvCumulativeMersenneTwisterPathGenerator_swiginit(self, _QuantLib.new_InvCumulativeMersenneTwisterPathGenerator(*args))

    def next(self):
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_antithetic(self)

    def size(self):
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_size(self)

    def timeGrid(self):
        return _QuantLib.InvCumulativeMersenneTwisterPathGenerator_timeGrid(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterPathGenerator

# Register InvCumulativeMersenneTwisterPathGenerator in _QuantLib:
_QuantLib.InvCumulativeMersenneTwisterPathGenerator_swigregister(InvCumulativeMersenneTwisterPathGenerator)

class MultiPath(object):
    thisown = 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 at(self, j):
        return _QuantLib.MultiPath_at(self, j)

    def __getitem__(self, i):
        return _QuantLib.MultiPath___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_MultiPath

# Register MultiPath in _QuantLib:
_QuantLib.MultiPath_swigregister(MultiPath)

class SampleMultiPath(object):
    thisown = 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

# Register SampleMultiPath in _QuantLib:
_QuantLib.SampleMultiPath_swigregister(SampleMultiPath)

class GaussianMultiPathGenerator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, process, times, generator, brownianBridge=False):
        _QuantLib.GaussianMultiPathGenerator_swiginit(self, _QuantLib.new_GaussianMultiPathGenerator(process, times, generator, brownianBridge))

    def next(self):
        return _QuantLib.GaussianMultiPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.GaussianMultiPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianMultiPathGenerator

# Register GaussianMultiPathGenerator in _QuantLib:
_QuantLib.GaussianMultiPathGenerator_swigregister(GaussianMultiPathGenerator)

class BrownianBridge(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BrownianBridge_swiginit(self, _QuantLib.new_BrownianBridge(*args))

    def size(self):
        return _QuantLib.BrownianBridge_size(self)

    def times(self):
        return _QuantLib.BrownianBridge_times(self)

    def leftWeight(self):
        return _QuantLib.BrownianBridge_leftWeight(self)

    def rightWeight(self):
        return _QuantLib.BrownianBridge_rightWeight(self)

    def stdDeviation(self):
        return _QuantLib.BrownianBridge_stdDeviation(self)

    def transform(self, input):
        return _QuantLib.BrownianBridge_transform(self, input)

    def bridgeIndex(self):
        return _QuantLib.BrownianBridge_bridgeIndex(self)

    def leftIndex(self):
        return _QuantLib.BrownianBridge_leftIndex(self)

    def rightIndex(self):
        return _QuantLib.BrownianBridge_rightIndex(self)
    __swig_destroy__ = _QuantLib.delete_BrownianBridge

# Register BrownianBridge in _QuantLib:
_QuantLib.BrownianBridge_swigregister(BrownianBridge)

class RungeKutta(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, eps=1.0e-6, h1=1.0e-4, hmin=0.0):
        _QuantLib.RungeKutta_swiginit(self, _QuantLib.new_RungeKutta(eps, h1, hmin))

    def __call__(self, *args):
        return _QuantLib.RungeKutta___call__(self, *args)
    __swig_destroy__ = _QuantLib.delete_RungeKutta

# Register RungeKutta in _QuantLib:
_QuantLib.RungeKutta_swigregister(RungeKutta)

class DefaultBoundaryCondition(object):
    thisown = 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
    NoSide = _QuantLib.DefaultBoundaryCondition_NoSide
    Upper = _QuantLib.DefaultBoundaryCondition_Upper
    Lower = _QuantLib.DefaultBoundaryCondition_Lower
    __swig_destroy__ = _QuantLib.delete_DefaultBoundaryCondition

# Register DefaultBoundaryCondition in _QuantLib:
_QuantLib.DefaultBoundaryCondition_swigregister(DefaultBoundaryCondition)

class NeumannBC(DefaultBoundaryCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, value, side):
        _QuantLib.NeumannBC_swiginit(self, _QuantLib.new_NeumannBC(value, side))
    __swig_destroy__ = _QuantLib.delete_NeumannBC

# Register NeumannBC in _QuantLib:
_QuantLib.NeumannBC_swigregister(NeumannBC)

class DirichletBC(DefaultBoundaryCondition):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, value, side):
        _QuantLib.DirichletBC_swiginit(self, _QuantLib.new_DirichletBC(value, side))
    __swig_destroy__ = _QuantLib.delete_DirichletBC

# Register DirichletBC in _QuantLib:
_QuantLib.DirichletBC_swigregister(DirichletBC)

class TridiagonalOperator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, low, mid, high):
        _QuantLib.TridiagonalOperator_swiginit(self, _QuantLib.new_TridiagonalOperator(low, mid, high))

    def solveFor(self, rhs):
        return _QuantLib.TridiagonalOperator_solveFor(self, rhs)

    def applyTo(self, v):
        return _QuantLib.TridiagonalOperator_applyTo(self, v)

    def size(self):
        return _QuantLib.TridiagonalOperator_size(self)

    def setFirstRow(self, arg2, arg3):
        return _QuantLib.TridiagonalOperator_setFirstRow(self, arg2, arg3)

    def setMidRow(self, arg2, arg3, arg4, arg5):
        return _QuantLib.TridiagonalOperator_setMidRow(self, arg2, arg3, arg4, arg5)

    def setMidRows(self, arg2, arg3, arg4):
        return _QuantLib.TridiagonalOperator_setMidRows(self, arg2, arg3, arg4)

    def setLastRow(self, arg2, arg3):
        return _QuantLib.TridiagonalOperator_setLastRow(self, arg2, arg3)

    @staticmethod
    def identity(size):
        return _QuantLib.TridiagonalOperator_identity(size)

    def __add__(self, O):
        return _QuantLib.TridiagonalOperator___add__(self, O)

    def __sub__(self, O):
        return _QuantLib.TridiagonalOperator___sub__(self, O)

    def __mul__(self, a):
        return _QuantLib.TridiagonalOperator___mul__(self, a)

    def __div__(self, a):
        return _QuantLib.TridiagonalOperator___div__(self, a)

    def __iadd__(self, O):
        return _QuantLib.TridiagonalOperator___iadd__(self, O)

    def __isub__(self, O):
        return _QuantLib.TridiagonalOperator___isub__(self, O)

    def __imul__(self, a):
        return _QuantLib.TridiagonalOperator___imul__(self, a)

    def __rmul__(self, a):
        return _QuantLib.TridiagonalOperator___rmul__(self, a)

    def __idiv__(self, a):
        return _QuantLib.TridiagonalOperator___idiv__(self, a)
    __swig_destroy__ = _QuantLib.delete_TridiagonalOperator

# Register TridiagonalOperator in _QuantLib:
_QuantLib.TridiagonalOperator_swigregister(TridiagonalOperator)

def TridiagonalOperator_identity(size):
    return _QuantLib.TridiagonalOperator_identity(size)

class DPlus(TridiagonalOperator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        _QuantLib.DPlus_swiginit(self, _QuantLib.new_DPlus(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DPlus

# Register DPlus in _QuantLib:
_QuantLib.DPlus_swigregister(DPlus)

class DMinus(TridiagonalOperator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        _QuantLib.DMinus_swiginit(self, _QuantLib.new_DMinus(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DMinus

# Register DMinus in _QuantLib:
_QuantLib.DMinus_swigregister(DMinus)

class DZero(TridiagonalOperator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        _QuantLib.DZero_swiginit(self, _QuantLib.new_DZero(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DZero

# Register DZero in _QuantLib:
_QuantLib.DZero_swigregister(DZero)

class DPlusDMinus(TridiagonalOperator):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        _QuantLib.DPlusDMinus_swiginit(self, _QuantLib.new_DPlusDMinus(gridPoints, h))
    __swig_destroy__ = _QuantLib.delete_DPlusDMinus

# Register DPlusDMinus in _QuantLib:
_QuantLib.DPlusDMinus_swigregister(DPlusDMinus)

class SampledCurve(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SampledCurve_swiginit(self, _QuantLib.new_SampledCurve(*args))

    def grid(self):
        return _QuantLib.SampledCurve_grid(self)

    def values(self):
        return _QuantLib.SampledCurve_values(self)

    def gridValue(self, i):
        return _QuantLib.SampledCurve_gridValue(self, i)

    def value(self, i):
        return _QuantLib.SampledCurve_value(self, i)

    def size(self):
        return _QuantLib.SampledCurve_size(self)

    def empty(self):
        return _QuantLib.SampledCurve_empty(self)

    def setGrid(self, arg2):
        return _QuantLib.SampledCurve_setGrid(self, arg2)

    def setValues(self, arg2):
        return _QuantLib.SampledCurve_setValues(self, arg2)

    def swap(self, arg2):
        return _QuantLib.SampledCurve_swap(self, arg2)

    def setLogGrid(self, min, max):
        return _QuantLib.SampledCurve_setLogGrid(self, min, max)

    def regridLogGrid(self, min, max):
        return _QuantLib.SampledCurve_regridLogGrid(self, min, max)

    def shiftGrid(self, s):
        return _QuantLib.SampledCurve_shiftGrid(self, s)

    def scaleGrid(self, s):
        return _QuantLib.SampledCurve_scaleGrid(self, s)

    def regrid(self, arg2):
        return _QuantLib.SampledCurve_regrid(self, arg2)
    __swig_destroy__ = _QuantLib.delete_SampledCurve

# Register SampledCurve in _QuantLib:
_QuantLib.SampledCurve_swigregister(SampledCurve)

class HestonSLVProcess(StochasticProcess):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, hestonProcess, leverageFct, mixingFactor=1.0):
        _QuantLib.HestonSLVProcess_swiginit(self, _QuantLib.new_HestonSLVProcess(hestonProcess, leverageFct, mixingFactor))
    __swig_destroy__ = _QuantLib.delete_HestonSLVProcess

# Register HestonSLVProcess in _QuantLib:
_QuantLib.HestonSLVProcess_swigregister(HestonSLVProcess)

class BrownianGeneratorFactory(object):
    thisown = 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_BrownianGeneratorFactory

# Register BrownianGeneratorFactory in _QuantLib:
_QuantLib.BrownianGeneratorFactory_swigregister(BrownianGeneratorFactory)

class MTBrownianGeneratorFactory(BrownianGeneratorFactory):
    thisown = 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):
        _QuantLib.MTBrownianGeneratorFactory_swiginit(self, _QuantLib.new_MTBrownianGeneratorFactory(seed))
    __swig_destroy__ = _QuantLib.delete_MTBrownianGeneratorFactory

# Register MTBrownianGeneratorFactory in _QuantLib:
_QuantLib.MTBrownianGeneratorFactory_swigregister(MTBrownianGeneratorFactory)

class SobolBrownianGenerator(object):
    thisown = 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
    Factors = _QuantLib.SobolBrownianGenerator_Factors
    Steps = _QuantLib.SobolBrownianGenerator_Steps
    Diagonal = _QuantLib.SobolBrownianGenerator_Diagonal
    __swig_destroy__ = _QuantLib.delete_SobolBrownianGenerator

# Register SobolBrownianGenerator in _QuantLib:
_QuantLib.SobolBrownianGenerator_swigregister(SobolBrownianGenerator)

class SobolBrownianGeneratorFactory(BrownianGeneratorFactory):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.SobolBrownianGeneratorFactory_swiginit(self, _QuantLib.new_SobolBrownianGeneratorFactory(*args))
    __swig_destroy__ = _QuantLib.delete_SobolBrownianGeneratorFactory

# Register SobolBrownianGeneratorFactory in _QuantLib:
_QuantLib.SobolBrownianGeneratorFactory_swigregister(SobolBrownianGeneratorFactory)

class HestonSLVMCModel(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HestonSLVMCModel_swiginit(self, _QuantLib.new_HestonSLVMCModel(*args))

    def hestonProcess(self):
        return _QuantLib.HestonSLVMCModel_hestonProcess(self)

    def localVol(self):
        return _QuantLib.HestonSLVMCModel_localVol(self)

    def leverageFunction(self):
        return _QuantLib.HestonSLVMCModel_leverageFunction(self)
    __swig_destroy__ = _QuantLib.delete_HestonSLVMCModel

# Register HestonSLVMCModel in _QuantLib:
_QuantLib.HestonSLVMCModel_swigregister(HestonSLVMCModel)

class FdmHestonGreensFct(object):
    thisown = 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
    ZeroCorrelation = _QuantLib.FdmHestonGreensFct_ZeroCorrelation
    Gaussian = _QuantLib.FdmHestonGreensFct_Gaussian
    SemiAnalytical = _QuantLib.FdmHestonGreensFct_SemiAnalytical
    __swig_destroy__ = _QuantLib.delete_FdmHestonGreensFct

# Register FdmHestonGreensFct in _QuantLib:
_QuantLib.FdmHestonGreensFct_swigregister(FdmHestonGreensFct)

class HestonSLVFokkerPlanckFdmParams(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, xGrid, vGrid, tMaxStepsPerYear, tMinStepsPerYear, tStepNumberDecay, nRannacherTimeSteps, predictionCorretionSteps, x0Density, localVolEpsProb, maxIntegrationIterations, vLowerEps, vUpperEps, vMin, v0Density, vLowerBoundDensity, vUpperBoundDensity, leverageFctPropEps, greensAlgorithm, trafoType, schemeDesc):
        _QuantLib.HestonSLVFokkerPlanckFdmParams_swiginit(self, _QuantLib.new_HestonSLVFokkerPlanckFdmParams(xGrid, vGrid, tMaxStepsPerYear, tMinStepsPerYear, tStepNumberDecay, nRannacherTimeSteps, predictionCorretionSteps, x0Density, localVolEpsProb, maxIntegrationIterations, vLowerEps, vUpperEps, vMin, v0Density, vLowerBoundDensity, vUpperBoundDensity, leverageFctPropEps, greensAlgorithm, trafoType, schemeDesc))
    __swig_destroy__ = _QuantLib.delete_HestonSLVFokkerPlanckFdmParams

# Register HestonSLVFokkerPlanckFdmParams in _QuantLib:
_QuantLib.HestonSLVFokkerPlanckFdmParams_swigregister(HestonSLVFokkerPlanckFdmParams)

class HestonSLVFDMModel(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.HestonSLVFDMModel_swiginit(self, _QuantLib.new_HestonSLVFDMModel(*args))

    def hestonProcess(self):
        return _QuantLib.HestonSLVFDMModel_hestonProcess(self)

    def localVol(self):
        return _QuantLib.HestonSLVFDMModel_localVol(self)

    def leverageFunction(self):
        return _QuantLib.HestonSLVFDMModel_leverageFunction(self)
    __swig_destroy__ = _QuantLib.delete_HestonSLVFDMModel

# Register HestonSLVFDMModel in _QuantLib:
_QuantLib.HestonSLVFDMModel_swigregister(HestonSLVFDMModel)

class Statistics(object):
    thisown = 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):
        _QuantLib.Statistics_swiginit(self, _QuantLib.new_Statistics())
    __swig_destroy__ = _QuantLib.delete_Statistics

# Register Statistics in _QuantLib:
_QuantLib.Statistics_swigregister(Statistics)

class IncrementalStatistics(object):
    thisown = 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.IncrementalStatistics_samples(self)

    def weightSum(self):
        return _QuantLib.IncrementalStatistics_weightSum(self)

    def mean(self):
        return _QuantLib.IncrementalStatistics_mean(self)

    def variance(self):
        return _QuantLib.IncrementalStatistics_variance(self)

    def standardDeviation(self):
        return _QuantLib.IncrementalStatistics_standardDeviation(self)

    def errorEstimate(self):
        return _QuantLib.IncrementalStatistics_errorEstimate(self)

    def skewness(self):
        return _QuantLib.IncrementalStatistics_skewness(self)

    def kurtosis(self):
        return _QuantLib.IncrementalStatistics_kurtosis(self)

    def min(self):
        return _QuantLib.IncrementalStatistics_min(self)

    def max(self):
        return _QuantLib.IncrementalStatistics_max(self)

    def reset(self):
        return _QuantLib.IncrementalStatistics_reset(self)

    def add(self, *args):
        return _QuantLib.IncrementalStatistics_add(self, *args)

    def __init__(self):
        _QuantLib.IncrementalStatistics_swiginit(self, _QuantLib.new_IncrementalStatistics())
    __swig_destroy__ = _QuantLib.delete_IncrementalStatistics

# Register IncrementalStatistics in _QuantLib:
_QuantLib.IncrementalStatistics_swigregister(IncrementalStatistics)

class RiskStatistics(Statistics):
    thisown = 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, target):
        return _QuantLib.RiskStatistics_regret(self, target)

    def potentialUpside(self, percentile):
        return _QuantLib.RiskStatistics_potentialUpside(self, percentile)

    def valueAtRisk(self, percentile):
        return _QuantLib.RiskStatistics_valueAtRisk(self, percentile)

    def expectedShortfall(self, percentile):
        return _QuantLib.RiskStatistics_expectedShortfall(self, percentile)

    def shortfall(self, target):
        return _QuantLib.RiskStatistics_shortfall(self, target)

    def averageShortfall(self, target):
        return _QuantLib.RiskStatistics_averageShortfall(self, target)

    def __init__(self):
        _QuantLib.RiskStatistics_swiginit(self, _QuantLib.new_RiskStatistics())
    __swig_destroy__ = _QuantLib.delete_RiskStatistics

# Register RiskStatistics in _QuantLib:
_QuantLib.RiskStatistics_swigregister(RiskStatistics)

class MultipleStatistics(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimension):
        _QuantLib.MultipleStatistics_swiginit(self, _QuantLib.new_MultipleStatistics(dimension))

    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

# Register MultipleStatistics in _QuantLib:
_QuantLib.MultipleStatistics_swigregister(MultipleStatistics)

class SequenceStatistics(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimension):
        _QuantLib.SequenceStatistics_swiginit(self, _QuantLib.new_SequenceStatistics(dimension))

    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

# Register SequenceStatistics in _QuantLib:
_QuantLib.SequenceStatistics_swigregister(SequenceStatistics)

class MultipleIncrementalStatistics(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dimension):
        _QuantLib.MultipleIncrementalStatistics_swiginit(self, _QuantLib.new_MultipleIncrementalStatistics(dimension))

    def size(self):
        return _QuantLib.MultipleIncrementalStatistics_size(self)

    def samples(self):
        return _QuantLib.MultipleIncrementalStatistics_samples(self)

    def weightSum(self):
        return _QuantLib.MultipleIncrementalStatistics_weightSum(self)

    def mean(self):
        return _QuantLib.MultipleIncrementalStatistics_mean(self)

    def variance(self):
        return _QuantLib.MultipleIncrementalStatistics_variance(self)

    def standardDeviation(self):
        return _QuantLib.MultipleIncrementalStatistics_standardDeviation(self)

    def errorEstimate(self):
        return _QuantLib.MultipleIncrementalStatistics_errorEstimate(self)

    def skewness(self):
        return _QuantLib.MultipleIncrementalStatistics_skewness(self)

    def kurtosis(self):
        return _QuantLib.MultipleIncrementalStatistics_kurtosis(self)

    def min(self):
        return _QuantLib.MultipleIncrementalStatistics_min(self)

    def max(self):
        return _QuantLib.MultipleIncrementalStatistics_max(self)

    def covariance(self):
        return _QuantLib.MultipleIncrementalStatistics_covariance(self)

    def correlation(self):
        return _QuantLib.MultipleIncrementalStatistics_correlation(self)

    def reset(self):
        return _QuantLib.MultipleIncrementalStatistics_reset(self)

    def add(self, *args):
        return _QuantLib.MultipleIncrementalStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_MultipleIncrementalStatistics

# Register MultipleIncrementalStatistics in _QuantLib:
_QuantLib.MultipleIncrementalStatistics_swigregister(MultipleIncrementalStatistics)

class CapFloorTermVolatilityStructure(VolatilityTermStructure):
    thisown = 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 volatility(self, *args):
        return _QuantLib.CapFloorTermVolatilityStructure_volatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructure

# Register CapFloorTermVolatilityStructure in _QuantLib:
_QuantLib.CapFloorTermVolatilityStructure_swigregister(CapFloorTermVolatilityStructure)

class CapFloorTermVolatilityStructureHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CapFloorTermVolatilityStructureHandle_swiginit(self, _QuantLib.new_CapFloorTermVolatilityStructureHandle(*args))

    def __deref__(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle___deref__(self)

    def currentLink(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_currentLink(self)

    def __nonzero__(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle___nonzero__(self)

    def __bool__(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle___bool__(self)

    def asObservable(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_asObservable(self)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructureHandle

    def volatility(self, *args):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_volatility(self, *args)

    def minStrike(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_maxStrike(self)

    def dayCounter(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_dayCounter(self)

    def timeFromReference(self, date):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_timeFromReference(self, date)

    def calendar(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_maxTime(self)

    def enableExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_allowsExtrapolation(self)

# Register CapFloorTermVolatilityStructureHandle in _QuantLib:
_QuantLib.CapFloorTermVolatilityStructureHandle_swigregister(CapFloorTermVolatilityStructureHandle)

class RelinkableCapFloorTermVolatilityStructureHandle(CapFloorTermVolatilityStructureHandle):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_swiginit(self, _QuantLib.new_RelinkableCapFloorTermVolatilityStructureHandle(*args))

    def linkTo(self, arg2):
        return _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_linkTo(self, arg2)

    def reset(self):
        return _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_reset(self)
    __swig_destroy__ = _QuantLib.delete_RelinkableCapFloorTermVolatilityStructureHandle

# Register RelinkableCapFloorTermVolatilityStructureHandle in _QuantLib:
_QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_swigregister(RelinkableCapFloorTermVolatilityStructureHandle)

class CapFloorTermVolCurve(CapFloorTermVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CapFloorTermVolCurve_swiginit(self, _QuantLib.new_CapFloorTermVolCurve(*args))
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolCurve

# Register CapFloorTermVolCurve in _QuantLib:
_QuantLib.CapFloorTermVolCurve_swigregister(CapFloorTermVolCurve)

class CapFloorTermVolSurface(CapFloorTermVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CapFloorTermVolSurface_swiginit(self, _QuantLib.new_CapFloorTermVolSurface(*args))

    def maxDate(self):
        return _QuantLib.CapFloorTermVolSurface_maxDate(self)

    def minStrike(self):
        return _QuantLib.CapFloorTermVolSurface_minStrike(self)

    def maxStrike(self):
        return _QuantLib.CapFloorTermVolSurface_maxStrike(self)

    def optionTenors(self):
        return _QuantLib.CapFloorTermVolSurface_optionTenors(self)

    def optionDates(self):
        return _QuantLib.CapFloorTermVolSurface_optionDates(self)

    def optionTimes(self):
        return _QuantLib.CapFloorTermVolSurface_optionTimes(self)

    def strikes(self):
        return _QuantLib.CapFloorTermVolSurface_strikes(self)
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolSurface

# Register CapFloorTermVolSurface in _QuantLib:
_QuantLib.CapFloorTermVolSurface_swigregister(CapFloorTermVolSurface)

class StrippedOptionletBase(object):
    thisown = 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 optionletStrikes(self, i):
        return _QuantLib.StrippedOptionletBase_optionletStrikes(self, i)

    def optionletVolatilities(self, i):
        return _QuantLib.StrippedOptionletBase_optionletVolatilities(self, i)

    def optionletFixingDates(self):
        return _QuantLib.StrippedOptionletBase_optionletFixingDates(self)

    def optionletFixingTimes(self):
        return _QuantLib.StrippedOptionletBase_optionletFixingTimes(self)

    def optionletMaturities(self):
        return _QuantLib.StrippedOptionletBase_optionletMaturities(self)

    def atmOptionletRates(self):
        return _QuantLib.StrippedOptionletBase_atmOptionletRates(self)

    def dayCounter(self):
        return _QuantLib.StrippedOptionletBase_dayCounter(self)

    def calendar(self):
        return _QuantLib.StrippedOptionletBase_calendar(self)

    def settlementDays(self):
        return _QuantLib.StrippedOptionletBase_settlementDays(self)

    def businessDayConvention(self):
        return _QuantLib.StrippedOptionletBase_businessDayConvention(self)
    __swig_destroy__ = _QuantLib.delete_StrippedOptionletBase

# Register StrippedOptionletBase in _QuantLib:
_QuantLib.StrippedOptionletBase_swigregister(StrippedOptionletBase)

class OptionletStripper1(StrippedOptionletBase):
    thisown = 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):
        _QuantLib.OptionletStripper1_swiginit(self, _QuantLib.new_OptionletStripper1(*args, **kwargs))

    def capFloorPrices(self):
        return _QuantLib.OptionletStripper1_capFloorPrices(self)

    def capFloorVolatilities(self):
        return _QuantLib.OptionletStripper1_capFloorVolatilities(self)

    def optionletPrices(self):
        return _QuantLib.OptionletStripper1_optionletPrices(self)

    def switchStrike(self):
        return _QuantLib.OptionletStripper1_switchStrike(self)
    __swig_destroy__ = _QuantLib.delete_OptionletStripper1

# Register OptionletStripper1 in _QuantLib:
_QuantLib.OptionletStripper1_swigregister(OptionletStripper1)

class StrippedOptionletAdapter(OptionletVolatilityStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _QuantLib.StrippedOptionletAdapter_swiginit(self, _QuantLib.new_StrippedOptionletAdapter(arg2))
    __swig_destroy__ = _QuantLib.delete_StrippedOptionletAdapter

# Register StrippedOptionletAdapter in _QuantLib:
_QuantLib.StrippedOptionletAdapter_swigregister(StrippedOptionletAdapter)

class Settlement(object):
    thisown = 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
    PhysicalOTC = _QuantLib.Settlement_PhysicalOTC
    PhysicalCleared = _QuantLib.Settlement_PhysicalCleared
    CollateralizedCashPrice = _QuantLib.Settlement_CollateralizedCashPrice
    ParYieldCurve = _QuantLib.Settlement_ParYieldCurve

    def __init__(self):
        _QuantLib.Settlement_swiginit(self, _QuantLib.new_Settlement())
    __swig_destroy__ = _QuantLib.delete_Settlement

# Register Settlement in _QuantLib:
_QuantLib.Settlement_swigregister(Settlement)

class Swaption(Option):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.Swaption_swiginit(self, _QuantLib.new_Swaption(*args))

    def settlementType(self):
        return _QuantLib.Swaption_settlementType(self)

    def settlementMethod(self):
        return _QuantLib.Swaption_settlementMethod(self)

    def type(self):
        return _QuantLib.Swaption_type(self)

    def underlyingSwap(self):
        return _QuantLib.Swaption_underlyingSwap(self)

    def impliedVolatility(self, price, discountCurve, guess, accuracy=1.0e-4, maxEvaluations=100, minVol=1.0e-7, maxVol=4.0, type=ShiftedLognormal, displacement=0.0):
        return _QuantLib.Swaption_impliedVolatility(self, price, discountCurve, guess, accuracy, maxEvaluations, minVol, maxVol, type, displacement)

    def vega(self):
        return _QuantLib.Swaption_vega(self)

    def delta(self):
        return _QuantLib.Swaption_delta(self)

    def annuity(self):
        return _QuantLib.Swaption_annuity(self)
    __swig_destroy__ = _QuantLib.delete_Swaption

# Register Swaption in _QuantLib:
_QuantLib.Swaption_swigregister(Swaption)

class NonstandardSwaption(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NonstandardSwaption_swiginit(self, _QuantLib.new_NonstandardSwaption(*args))

    def underlyingSwap(self):
        return _QuantLib.NonstandardSwaption_underlyingSwap(self)

    def calibrationBasket(self, swapIndex, swaptionVolatility, typeStr):
        return _QuantLib.NonstandardSwaption_calibrationBasket(self, swapIndex, swaptionVolatility, typeStr)

    def probabilities(self):
        return _QuantLib.NonstandardSwaption_probabilities(self)
    __swig_destroy__ = _QuantLib.delete_NonstandardSwaption

# Register NonstandardSwaption in _QuantLib:
_QuantLib.NonstandardSwaption_swigregister(NonstandardSwaption)

class FloatFloatSwaption(Instrument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.FloatFloatSwaption_swiginit(self, _QuantLib.new_FloatFloatSwaption(*args))

    def underlyingSwap(self):
        return _QuantLib.FloatFloatSwaption_underlyingSwap(self)

    def calibrationBasket(self, swapIndex, swaptionVolatility, typeStr):
        return _QuantLib.FloatFloatSwaption_calibrationBasket(self, swapIndex, swaptionVolatility, typeStr)

    def underlyingValue(self):
        return _QuantLib.FloatFloatSwaption_underlyingValue(self)

    def probabilities(self):
        return _QuantLib.FloatFloatSwaption_probabilities(self)
    __swig_destroy__ = _QuantLib.delete_FloatFloatSwaption

# Register FloatFloatSwaption in _QuantLib:
_QuantLib.FloatFloatSwaption_swigregister(FloatFloatSwaption)

class BlackSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BlackSwaptionEngine_swiginit(self, _QuantLib.new_BlackSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BlackSwaptionEngine

# Register BlackSwaptionEngine in _QuantLib:
_QuantLib.BlackSwaptionEngine_swigregister(BlackSwaptionEngine)

class BachelierSwaptionEngine(PricingEngine):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.BachelierSwaptionEngine_swiginit(self, _QuantLib.new_BachelierSwaptionEngine(*args))
    __swig_destroy__ = _QuantLib.delete_BachelierSwaptionEngine

# Register BachelierSwaptionEngine in _QuantLib:
_QuantLib.BachelierSwaptionEngine_swigregister(BachelierSwaptionEngine)


def enableTracing():
    return _QuantLib.enableTracing()

def disableTracing():
    return _QuantLib.disableTracing()
class ConstantEstimator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, size):
        _QuantLib.ConstantEstimator_swiginit(self, _QuantLib.new_ConstantEstimator(size))

    def calculate(self, arg2):
        return _QuantLib.ConstantEstimator_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_ConstantEstimator

# Register ConstantEstimator in _QuantLib:
_QuantLib.ConstantEstimator_swigregister(ConstantEstimator)

class ParkinsonSigma(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        _QuantLib.ParkinsonSigma_swiginit(self, _QuantLib.new_ParkinsonSigma(yearFraction))

    def calculate(self, arg2):
        return _QuantLib.ParkinsonSigma_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_ParkinsonSigma

# Register ParkinsonSigma in _QuantLib:
_QuantLib.ParkinsonSigma_swigregister(ParkinsonSigma)

class GarmanKlassSigma1(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        _QuantLib.GarmanKlassSigma1_swiginit(self, _QuantLib.new_GarmanKlassSigma1(yearFraction, marketOpenFraction))

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma1_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma1

# Register GarmanKlassSigma1 in _QuantLib:
_QuantLib.GarmanKlassSigma1_swigregister(GarmanKlassSigma1)

class GarmanKlassSigma3(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        _QuantLib.GarmanKlassSigma3_swiginit(self, _QuantLib.new_GarmanKlassSigma3(yearFraction, marketOpenFraction))

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma3_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma3

# Register GarmanKlassSigma3 in _QuantLib:
_QuantLib.GarmanKlassSigma3_swigregister(GarmanKlassSigma3)

class GarmanKlassSigma4(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        _QuantLib.GarmanKlassSigma4_swiginit(self, _QuantLib.new_GarmanKlassSigma4(yearFraction))

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma4_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma4

# Register GarmanKlassSigma4 in _QuantLib:
_QuantLib.GarmanKlassSigma4_swigregister(GarmanKlassSigma4)

class GarmanKlassSigma5(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        _QuantLib.GarmanKlassSigma5_swiginit(self, _QuantLib.new_GarmanKlassSigma5(yearFraction))

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma5_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma5

# Register GarmanKlassSigma5 in _QuantLib:
_QuantLib.GarmanKlassSigma5_swigregister(GarmanKlassSigma5)

class GarmanKlassSigma6(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        _QuantLib.GarmanKlassSigma6_swiginit(self, _QuantLib.new_GarmanKlassSigma6(yearFraction, marketOpenFraction))

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma6_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma6

# Register GarmanKlassSigma6 in _QuantLib:
_QuantLib.GarmanKlassSigma6_swigregister(GarmanKlassSigma6)

class ZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.ZeroCurve_swiginit(self, _QuantLib.new_ZeroCurve(*args))

    def times(self):
        return _QuantLib.ZeroCurve_times(self)

    def data(self):
        return _QuantLib.ZeroCurve_data(self)

    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

# Register ZeroCurve in _QuantLib:
_QuantLib.ZeroCurve_swigregister(ZeroCurve)

class LogLinearZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LogLinearZeroCurve_swiginit(self, _QuantLib.new_LogLinearZeroCurve(*args))

    def times(self):
        return _QuantLib.LogLinearZeroCurve_times(self)

    def data(self):
        return _QuantLib.LogLinearZeroCurve_data(self)

    def dates(self):
        return _QuantLib.LogLinearZeroCurve_dates(self)

    def zeroRates(self):
        return _QuantLib.LogLinearZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.LogLinearZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_LogLinearZeroCurve

# Register LogLinearZeroCurve in _QuantLib:
_QuantLib.LogLinearZeroCurve_swigregister(LogLinearZeroCurve)

class CubicZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.CubicZeroCurve_swiginit(self, _QuantLib.new_CubicZeroCurve(*args))

    def times(self):
        return _QuantLib.CubicZeroCurve_times(self)

    def data(self):
        return _QuantLib.CubicZeroCurve_data(self)

    def dates(self):
        return _QuantLib.CubicZeroCurve_dates(self)

    def zeroRates(self):
        return _QuantLib.CubicZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.CubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_CubicZeroCurve

# Register CubicZeroCurve in _QuantLib:
_QuantLib.CubicZeroCurve_swigregister(CubicZeroCurve)

class NaturalCubicZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.NaturalCubicZeroCurve_swiginit(self, _QuantLib.new_NaturalCubicZeroCurve(*args))

    def times(self):
        return _QuantLib.NaturalCubicZeroCurve_times(self)

    def data(self):
        return _QuantLib.NaturalCubicZeroCurve_data(self)

    def dates(self):
        return _QuantLib.NaturalCubicZeroCurve_dates(self)

    def zeroRates(self):
        return _QuantLib.NaturalCubicZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.NaturalCubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_NaturalCubicZeroCurve

# Register NaturalCubicZeroCurve in _QuantLib:
_QuantLib.NaturalCubicZeroCurve_swigregister(NaturalCubicZeroCurve)

class LogCubicZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.LogCubicZeroCurve_swiginit(self, _QuantLib.new_LogCubicZeroCurve(*args))

    def times(self):
        return _QuantLib.LogCubicZeroCurve_times(self)

    def data(self):
        return _QuantLib.LogCubicZeroCurve_data(self)

    def dates(self):
        return _QuantLib.LogCubicZeroCurve_dates(self)

    def zeroRates(self):
        return _QuantLib.LogCubicZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.LogCubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_LogCubicZeroCurve

# Register LogCubicZeroCurve in _QuantLib:
_QuantLib.LogCubicZeroCurve_swigregister(LogCubicZeroCurve)

class MonotonicCubicZeroCurve(YieldTermStructure):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _QuantLib.MonotonicCubicZeroCurve_swiginit(self, _QuantLib.new_MonotonicCubicZeroCurve(*args))

    def times(self):
        return _QuantLib.MonotonicCubicZeroCurve_times(self)

    def data(self):
        return _QuantLib.MonotonicCubicZeroCurve_data(self)

    def dates(self):
        return _QuantLib.MonotonicCubicZeroCurve_dates(self)

    def zeroRates(self):
        return _QuantLib.MonotonicCubicZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.MonotonicCubicZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_MonotonicCubicZeroCurve

# Register MonotonicCubicZeroCurve in _QuantLib:
_QuantLib.MonotonicCubicZeroCurve_swigregister(MonotonicCubicZeroCurve)



