# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_QuantLib')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_QuantLib')
    _QuantLib = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_QuantLib', [dirname(__file__)])
        except ImportError:
            import _QuantLib
            return _QuantLib
        try:
            _mod = imp.load_module('_QuantLib', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _QuantLib = swig_import_helper()
    del swig_import_helper
else:
    import _QuantLib
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class SwigPyIterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_SwigPyIterator
    __del__ = lambda self: None

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

    def incr(self, n=1):
        return _QuantLib.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _QuantLib.SwigPyIterator_decr(self, n)

    def distance(self, 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
SwigPyIterator_swigregister = _QuantLib.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
cvar = _QuantLib.cvar
__hexversion__ = cvar.__hexversion__
__version__ = cvar.__version__

Sunday = _QuantLib.Sunday
Monday = _QuantLib.Monday
Tuesday = _QuantLib.Tuesday
Wednesday = _QuantLib.Wednesday
Thursday = _QuantLib.Thursday
Friday = _QuantLib.Friday
Saturday = _QuantLib.Saturday
January = _QuantLib.January
February = _QuantLib.February
March = _QuantLib.March
April = _QuantLib.April
May = _QuantLib.May
June = _QuantLib.June
July = _QuantLib.July
August = _QuantLib.August
September = _QuantLib.September
October = _QuantLib.October
November = _QuantLib.November
December = _QuantLib.December
Days = _QuantLib.Days
Weeks = _QuantLib.Weeks
Months = _QuantLib.Months
Years = _QuantLib.Years
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 = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def length(self):
        return _QuantLib.Period_length(self)

    def units(self):
        return _QuantLib.Period_units(self)

    def frequency(self):
        return _QuantLib.Period_frequency(self)

    def __init__(self, *args):
        this = _QuantLib.new_Period(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def __repr__(self):
        return _QuantLib.Period___repr__(self)

    def __neg__(self):
        return _QuantLib.Period___neg__(self)

    def __mul__(self, 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
    __del__ = lambda self: None
Period_swigregister = _QuantLib.Period_swigregister
Period_swigregister(Period)

class PeriodVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.PeriodVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_PeriodVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PeriodVector_swigregister = _QuantLib.PeriodVector_swigregister
PeriodVector_swigregister(PeriodVector)


import datetime as _datetime

class Date(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def weekday(self):
        return _QuantLib.Date_weekday(self)

    def dayOfMonth(self):
        return _QuantLib.Date_dayOfMonth(self)

    def dayOfYear(self):
        return _QuantLib.Date_dayOfYear(self)

    def month(self):
        return _QuantLib.Date_month(self)

    def year(self):
        return _QuantLib.Date_year(self)

    def 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)
    isLeap = staticmethod(_QuantLib.Date_isLeap)
    minDate = staticmethod(_QuantLib.Date_minDate)
    maxDate = staticmethod(_QuantLib.Date_maxDate)
    todaysDate = staticmethod(_QuantLib.Date_todaysDate)
    localDateTime = staticmethod(_QuantLib.Date_localDateTime)
    universalDateTime = staticmethod(_QuantLib.Date_universalDateTime)
    endOfMonth = staticmethod(_QuantLib.Date_endOfMonth)
    isEndOfMonth = staticmethod(_QuantLib.Date_isEndOfMonth)
    nextWeekday = staticmethod(_QuantLib.Date_nextWeekday)
    nthWeekday = staticmethod(_QuantLib.Date_nthWeekday)

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

    def __init__(self, *args):
        this = _QuantLib.new_Date(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def weekdayNumber(self):
        return _QuantLib.Date_weekdayNumber(self)

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

    def __repr__(self):
        return _QuantLib.Date___repr__(self)

    def ISO(self):
        return _QuantLib.Date_ISO(self)

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

    def __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 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
    __del__ = lambda self: None
Date_swigregister = _QuantLib.Date_swigregister
Date_swigregister(Date)

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

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

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

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

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

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

def Date_endOfMonth(arg2):
    return _QuantLib.Date_endOfMonth(arg2)
Date_endOfMonth = _QuantLib.Date_endOfMonth

def Date_isEndOfMonth(arg2):
    return _QuantLib.Date_isEndOfMonth(arg2)
Date_isEndOfMonth = _QuantLib.Date_isEndOfMonth

def Date_nextWeekday(arg2, arg3):
    return _QuantLib.Date_nextWeekday(arg2, arg3)
Date_nextWeekday = _QuantLib.Date_nextWeekday

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

class DateParser(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    parseFormatted = staticmethod(_QuantLib.DateParser_parseFormatted)
    parseISO = staticmethod(_QuantLib.DateParser_parseISO)
    parse = staticmethod(_QuantLib.DateParser_parse)

    def __init__(self):
        this = _QuantLib.new_DateParser()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DateParser
    __del__ = lambda self: None
DateParser_swigregister = _QuantLib.DateParser_swigregister
DateParser_swigregister(DateParser)

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

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

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

class PeriodParser(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    parse = staticmethod(_QuantLib.PeriodParser_parse)

    def __init__(self):
        this = _QuantLib.new_PeriodParser()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PeriodParser
    __del__ = lambda self: None
PeriodParser_swigregister = _QuantLib.PeriodParser_swigregister
PeriodParser_swigregister(PeriodParser)

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


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

class DateVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.DateVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_DateVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
DateVector_swigregister = _QuantLib.DateVector_swigregister
DateVector_swigregister(DateVector)

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

    def __init__(self):
        this = _QuantLib.new_IMM()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IMM
    __del__ = lambda self: None
IMM_swigregister = _QuantLib.IMM_swigregister
IMM_swigregister(IMM)

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

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

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

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

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

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

class ASX(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    F = _QuantLib.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
    isASXdate = staticmethod(_QuantLib.ASX_isASXdate)
    isASXcode = staticmethod(_QuantLib.ASX_isASXcode)
    code = staticmethod(_QuantLib.ASX_code)
    date = staticmethod(_QuantLib.ASX_date)
    nextDate = staticmethod(_QuantLib.ASX_nextDate)
    nextCode = staticmethod(_QuantLib.ASX_nextCode)

    def __init__(self):
        this = _QuantLib.new_ASX()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ASX
    __del__ = lambda self: None
ASX_swigregister = _QuantLib.ASX_swigregister
ASX_swigregister(ASX)

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

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

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

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

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

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

class IntVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_IntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
IntVector_swigregister = _QuantLib.IntVector_swigregister
IntVector_swigregister(IntVector)

class UnsignedIntVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.UnsignedIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_UnsignedIntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
UnsignedIntVector_swigregister = _QuantLib.UnsignedIntVector_swigregister
UnsignedIntVector_swigregister(UnsignedIntVector)

class DoubleVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
DoubleVector_swigregister = _QuantLib.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class StrVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.StrVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_StrVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
StrVector_swigregister = _QuantLib.StrVector_swigregister
StrVector_swigregister(StrVector)

class BoolVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_BoolVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
BoolVector_swigregister = _QuantLib.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

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

    def __init__(self, *args):
        this = _QuantLib.new_NodePair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    first = _swig_property(_QuantLib.NodePair_first_get, _QuantLib.NodePair_first_set)
    second = _swig_property(_QuantLib.NodePair_second_get, _QuantLib.NodePair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _QuantLib.delete_NodePair
    __del__ = lambda self: None
NodePair_swigregister = _QuantLib.NodePair_swigregister
NodePair_swigregister(NodePair)

class NodeVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.NodeVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_NodeVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
NodeVector_swigregister = _QuantLib.NodeVector_swigregister
NodeVector_swigregister(NodeVector)

class Exercise(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

    def __bool__(self):
        return _QuantLib.Exercise___bool__(self)
    American = _QuantLib.Exercise_American
    Bermudan = _QuantLib.Exercise_Bermudan
    European = _QuantLib.Exercise_European

    def exerciseType(self):
        return _QuantLib.Exercise_exerciseType(self)

    def __init__(self):
        this = _QuantLib.new_Exercise()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Exercise
    __del__ = lambda self: None

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

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

    def lastDate(self):
        return _QuantLib.Exercise_lastDate(self)
Exercise_swigregister = _QuantLib.Exercise_swigregister
Exercise_swigregister(Exercise)

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

    def __init__(self, date):
        this = _QuantLib.new_EuropeanExercise(date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EuropeanExercise
    __del__ = lambda self: None
EuropeanExercise_swigregister = _QuantLib.EuropeanExercise_swigregister
EuropeanExercise_swigregister(EuropeanExercise)

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

    def __init__(self, earliestDate, latestDate, payoffAtExpiry=False):
        this = _QuantLib.new_AmericanExercise(earliestDate, latestDate, payoffAtExpiry)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AmericanExercise
    __del__ = lambda self: None
AmericanExercise_swigregister = _QuantLib.AmericanExercise_swigregister
AmericanExercise_swigregister(AmericanExercise)

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

    def __init__(self, dates, payoffAtExpiry=False):
        this = _QuantLib.new_BermudanExercise(dates, payoffAtExpiry)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BermudanExercise
    __del__ = lambda self: None
BermudanExercise_swigregister = _QuantLib.BermudanExercise_swigregister
BermudanExercise_swigregister(BermudanExercise)

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

    def __init__(self, *args):
        this = _QuantLib.new_RebatedExercise(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_RebatedExercise
    __del__ = lambda self: None
RebatedExercise_swigregister = _QuantLib.RebatedExercise_swigregister
RebatedExercise_swigregister(RebatedExercise)

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

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

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

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

    def __init__(self):
        this = _QuantLib.new_Observable()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Observable
    __del__ = lambda self: None
Observable_swigregister = _QuantLib.Observable_swigregister
Observable_swigregister(Observable)

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

    def __init__(self, callback):
        this = _QuantLib.new_Observer(callback)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

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

    def registerWith(self,x):
        self._registerWith(x.asObservable())
    def unregisterWith(self,x):
        self._unregisterWith(x.asObservable())

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

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

    def __init__(self, *args):
        this = _QuantLib.new_Array(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Array_swigregister = _QuantLib.Array_swigregister
Array_swigregister(Array)

class DefaultLexicographicalViewColumn(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def __setitem__(self, i, x):
        return _QuantLib.DefaultLexicographicalViewColumn___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_DefaultLexicographicalViewColumn
    __del__ = lambda self: None
DefaultLexicographicalViewColumn_swigregister = _QuantLib.DefaultLexicographicalViewColumn_swigregister
DefaultLexicographicalViewColumn_swigregister(DefaultLexicographicalViewColumn)

class LexicographicalView(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def xSize(self):
        return _QuantLib.LexicographicalView_xSize(self)

    def ySize(self):
        return _QuantLib.LexicographicalView_ySize(self)

    def __init__(self, a, xSize):
        this = _QuantLib.new_LexicographicalView(a, xSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def __getitem__(self, i):
        return _QuantLib.LexicographicalView___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_LexicographicalView
    __del__ = lambda self: None
LexicographicalView_swigregister = _QuantLib.LexicographicalView_swigregister
LexicographicalView_swigregister(LexicographicalView)

class MatrixRow(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def __setitem__(self, i, x):
        return _QuantLib.MatrixRow___setitem__(self, i, x)
    __swig_destroy__ = _QuantLib.delete_MatrixRow
    __del__ = lambda self: None
MatrixRow_swigregister = _QuantLib.MatrixRow_swigregister
MatrixRow_swigregister(MatrixRow)

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

    def __init__(self, *args):
        this = _QuantLib.new_Matrix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def rows(self):
        return _QuantLib.Matrix_rows(self)

    def columns(self):
        return _QuantLib.Matrix_columns(self)

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

    def __add__(self, 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
    __del__ = lambda self: None
Matrix_swigregister = _QuantLib.Matrix_swigregister
Matrix_swigregister(Matrix)

class SalvagingAlgorithm(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NoAlgorithm = _QuantLib.SalvagingAlgorithm_NoAlgorithm
    Spectral = _QuantLib.SalvagingAlgorithm_Spectral

    def __init__(self):
        this = _QuantLib.new_SalvagingAlgorithm()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SalvagingAlgorithm
    __del__ = lambda self: None
SalvagingAlgorithm_swigregister = _QuantLib.SalvagingAlgorithm_swigregister
SalvagingAlgorithm_swigregister(SalvagingAlgorithm)


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

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

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

    def __init__(self, arg2):
        this = _QuantLib.new_SVD(arg2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def U(self):
        return _QuantLib.SVD_U(self)

    def V(self):
        return _QuantLib.SVD_V(self)

    def S(self):
        return _QuantLib.SVD_S(self)

    def singularValues(self):
        return _QuantLib.SVD_singularValues(self)
    __swig_destroy__ = _QuantLib.delete_SVD
    __del__ = lambda self: None
SVD_swigregister = _QuantLib.SVD_swigregister
SVD_swigregister(SVD)

class Quote(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.Quote_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_Quote()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Quote
    __del__ = lambda self: None

    def value(self):
        return _QuantLib.Quote_value(self)
Quote_swigregister = _QuantLib.Quote_swigregister
Quote_swigregister(Quote)

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

    def __init__(self, *args):
        this = _QuantLib.new_QuoteHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.QuoteHandle___deref__(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
    __del__ = lambda self: None

    def value(self):
        return _QuantLib.QuoteHandle_value(self)
QuoteHandle_swigregister = _QuantLib.QuoteHandle_swigregister
QuoteHandle_swigregister(QuoteHandle)

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

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableQuoteHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableQuoteHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableQuoteHandle
    __del__ = lambda self: None
RelinkableQuoteHandle_swigregister = _QuantLib.RelinkableQuoteHandle_swigregister
RelinkableQuoteHandle_swigregister(RelinkableQuoteHandle)

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

    def __init__(self, value):
        this = _QuantLib.new_SimpleQuote(value)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setValue(self, value):
        return _QuantLib.SimpleQuote_setValue(self, value)
    __swig_destroy__ = _QuantLib.delete_SimpleQuote
    __del__ = lambda self: None
SimpleQuote_swigregister = _QuantLib.SimpleQuote_swigregister
SimpleQuote_swigregister(SimpleQuote)

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

    def __init__(self, h, function):
        this = _QuantLib.new_DerivedQuote(h, function)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DerivedQuote
    __del__ = lambda self: None
DerivedQuote_swigregister = _QuantLib.DerivedQuote_swigregister
DerivedQuote_swigregister(DerivedQuote)

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

    def __init__(self, h1, h2, function):
        this = _QuantLib.new_CompositeQuote(h1, h2, function)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CompositeQuote
    __del__ = lambda self: None
CompositeQuote_swigregister = _QuantLib.CompositeQuote_swigregister
CompositeQuote_swigregister(CompositeQuote)

class QuoteVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.QuoteVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_QuoteVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
QuoteVector_swigregister = _QuantLib.QuoteVector_swigregister
QuoteVector_swigregister(QuoteVector)

class QuoteVectorVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_QuoteVectorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
QuoteVectorVector_swigregister = _QuantLib.QuoteVectorVector_swigregister
QuoteVectorVector_swigregister(QuoteVectorVector)

class QuoteHandleVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.QuoteHandleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_QuoteHandleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
QuoteHandleVector_swigregister = _QuantLib.QuoteHandleVector_swigregister
QuoteHandleVector_swigregister(QuoteHandleVector)

class QuoteHandleVectorVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_QuoteHandleVectorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
QuoteHandleVectorVector_swigregister = _QuantLib.QuoteHandleVectorVector_swigregister
QuoteHandleVectorVector_swigregister(QuoteHandleVectorVector)

class RelinkableQuoteHandleVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.RelinkableQuoteHandleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_RelinkableQuoteHandleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
RelinkableQuoteHandleVector_swigregister = _QuantLib.RelinkableQuoteHandleVector_swigregister
RelinkableQuoteHandleVector_swigregister(RelinkableQuoteHandleVector)

class RelinkableQuoteHandleVectorVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_RelinkableQuoteHandleVectorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
RelinkableQuoteHandleVectorVector_swigregister = _QuantLib.RelinkableQuoteHandleVectorVector_swigregister
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 = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def 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, arg2, to, includeFirst=True, includeLast=False):
        return _QuantLib.Calendar_businessDaysBetween(self, arg2, to, includeFirst, includeLast)

    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
    __del__ = lambda self: None
Calendar_swigregister = _QuantLib.Calendar_swigregister
Calendar_swigregister(Calendar)

class Argentina(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Merval = _QuantLib.Argentina_Merval

    def __init__(self, *args):
        this = _QuantLib.new_Argentina(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Argentina
    __del__ = lambda self: None
Argentina_swigregister = _QuantLib.Argentina_swigregister
Argentina_swigregister(Argentina)

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

    def __init__(self):
        this = _QuantLib.new_Australia()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Australia
    __del__ = lambda self: None
Australia_swigregister = _QuantLib.Australia_swigregister
Australia_swigregister(Australia)

class Brazil(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Brazil_Settlement
    Exchange = _QuantLib.Brazil_Exchange

    def __init__(self, *args):
        this = _QuantLib.new_Brazil(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Brazil
    __del__ = lambda self: None
Brazil_swigregister = _QuantLib.Brazil_swigregister
Brazil_swigregister(Brazil)

class Canada(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Canada_Settlement
    TSX = _QuantLib.Canada_TSX

    def __init__(self, *args):
        this = _QuantLib.new_Canada(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Canada
    __del__ = lambda self: None
Canada_swigregister = _QuantLib.Canada_swigregister
Canada_swigregister(Canada)

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

    def __init__(self, *args):
        this = _QuantLib.new_China(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_China
    __del__ = lambda self: None
China_swigregister = _QuantLib.China_swigregister
China_swigregister(China)

class CzechRepublic(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    PSE = _QuantLib.CzechRepublic_PSE

    def __init__(self, *args):
        this = _QuantLib.new_CzechRepublic(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CzechRepublic
    __del__ = lambda self: None
CzechRepublic_swigregister = _QuantLib.CzechRepublic_swigregister
CzechRepublic_swigregister(CzechRepublic)

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

    def __init__(self):
        this = _QuantLib.new_Denmark()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Denmark
    __del__ = lambda self: None
Denmark_swigregister = _QuantLib.Denmark_swigregister
Denmark_swigregister(Denmark)

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

    def __init__(self):
        this = _QuantLib.new_Finland()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Finland
    __del__ = lambda self: None
Finland_swigregister = _QuantLib.Finland_swigregister
Finland_swigregister(Finland)

class Germany(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Germany_Settlement
    FrankfurtStockExchange = _QuantLib.Germany_FrankfurtStockExchange
    Xetra = _QuantLib.Germany_Xetra
    Eurex = _QuantLib.Germany_Eurex

    def __init__(self, *args):
        this = _QuantLib.new_Germany(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Germany
    __del__ = lambda self: None
Germany_swigregister = _QuantLib.Germany_swigregister
Germany_swigregister(Germany)

class HongKong(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    HKEx = _QuantLib.HongKong_HKEx

    def __init__(self, *args):
        this = _QuantLib.new_HongKong(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HongKong
    __del__ = lambda self: None
HongKong_swigregister = _QuantLib.HongKong_swigregister
HongKong_swigregister(HongKong)

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

    def __init__(self):
        this = _QuantLib.new_Hungary()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Hungary
    __del__ = lambda self: None
Hungary_swigregister = _QuantLib.Hungary_swigregister
Hungary_swigregister(Hungary)

class Iceland(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ICEX = _QuantLib.Iceland_ICEX

    def __init__(self, *args):
        this = _QuantLib.new_Iceland(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Iceland
    __del__ = lambda self: None
Iceland_swigregister = _QuantLib.Iceland_swigregister
Iceland_swigregister(Iceland)

class India(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NSE = _QuantLib.India_NSE

    def __init__(self, *args):
        this = _QuantLib.new_India(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_India
    __del__ = lambda self: None
India_swigregister = _QuantLib.India_swigregister
India_swigregister(India)

class Indonesia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BEJ = _QuantLib.Indonesia_BEJ
    JSX = _QuantLib.Indonesia_JSX

    def __init__(self, *args):
        this = _QuantLib.new_Indonesia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Indonesia
    __del__ = lambda self: None
Indonesia_swigregister = _QuantLib.Indonesia_swigregister
Indonesia_swigregister(Indonesia)

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

    def __init__(self, *args):
        this = _QuantLib.new_Israel(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Israel
    __del__ = lambda self: None
Israel_swigregister = _QuantLib.Israel_swigregister
Israel_swigregister(Israel)

class Italy(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.Italy_Settlement
    Exchange = _QuantLib.Italy_Exchange

    def __init__(self, *args):
        this = _QuantLib.new_Italy(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Italy
    __del__ = lambda self: None
Italy_swigregister = _QuantLib.Italy_swigregister
Italy_swigregister(Italy)

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

    def __init__(self):
        this = _QuantLib.new_Japan()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Japan
    __del__ = lambda self: None
Japan_swigregister = _QuantLib.Japan_swigregister
Japan_swigregister(Japan)

class Mexico(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BMV = _QuantLib.Mexico_BMV

    def __init__(self, *args):
        this = _QuantLib.new_Mexico(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Mexico
    __del__ = lambda self: None
Mexico_swigregister = _QuantLib.Mexico_swigregister
Mexico_swigregister(Mexico)

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

    def __init__(self):
        this = _QuantLib.new_NewZealand()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NewZealand
    __del__ = lambda self: None
NewZealand_swigregister = _QuantLib.NewZealand_swigregister
NewZealand_swigregister(NewZealand)

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

    def __init__(self):
        this = _QuantLib.new_Norway()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Norway
    __del__ = lambda self: None
Norway_swigregister = _QuantLib.Norway_swigregister
Norway_swigregister(Norway)

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

    def __init__(self):
        this = _QuantLib.new_Poland()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Poland
    __del__ = lambda self: None
Poland_swigregister = _QuantLib.Poland_swigregister
Poland_swigregister(Poland)

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

    def __init__(self, *args):
        this = _QuantLib.new_Russia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Russia
    __del__ = lambda self: None
Russia_swigregister = _QuantLib.Russia_swigregister
Russia_swigregister(Russia)

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

    def __init__(self):
        this = _QuantLib.new_Romania()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Romania
    __del__ = lambda self: None
Romania_swigregister = _QuantLib.Romania_swigregister
Romania_swigregister(Romania)

class SaudiArabia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Tadawul = _QuantLib.SaudiArabia_Tadawul

    def __init__(self, *args):
        this = _QuantLib.new_SaudiArabia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SaudiArabia
    __del__ = lambda self: None
SaudiArabia_swigregister = _QuantLib.SaudiArabia_swigregister
SaudiArabia_swigregister(SaudiArabia)

class Singapore(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SGX = _QuantLib.Singapore_SGX

    def __init__(self, *args):
        this = _QuantLib.new_Singapore(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Singapore
    __del__ = lambda self: None
Singapore_swigregister = _QuantLib.Singapore_swigregister
Singapore_swigregister(Singapore)

class Slovakia(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BSSE = _QuantLib.Slovakia_BSSE

    def __init__(self, *args):
        this = _QuantLib.new_Slovakia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Slovakia
    __del__ = lambda self: None
Slovakia_swigregister = _QuantLib.Slovakia_swigregister
Slovakia_swigregister(Slovakia)

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

    def __init__(self):
        this = _QuantLib.new_SouthAfrica()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SouthAfrica
    __del__ = lambda self: None
SouthAfrica_swigregister = _QuantLib.SouthAfrica_swigregister
SouthAfrica_swigregister(SouthAfrica)

class SouthKorea(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.SouthKorea_Settlement
    KRX = _QuantLib.SouthKorea_KRX

    def __init__(self, *args):
        this = _QuantLib.new_SouthKorea(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SouthKorea
    __del__ = lambda self: None
SouthKorea_swigregister = _QuantLib.SouthKorea_swigregister
SouthKorea_swigregister(SouthKorea)

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

    def __init__(self):
        this = _QuantLib.new_Sweden()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Sweden
    __del__ = lambda self: None
Sweden_swigregister = _QuantLib.Sweden_swigregister
Sweden_swigregister(Sweden)

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

    def __init__(self):
        this = _QuantLib.new_Switzerland()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Switzerland
    __del__ = lambda self: None
Switzerland_swigregister = _QuantLib.Switzerland_swigregister
Switzerland_swigregister(Switzerland)

class Taiwan(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    TSEC = _QuantLib.Taiwan_TSEC

    def __init__(self, *args):
        this = _QuantLib.new_Taiwan(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Taiwan
    __del__ = lambda self: None
Taiwan_swigregister = _QuantLib.Taiwan_swigregister
Taiwan_swigregister(Taiwan)

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

    def __init__(self):
        this = _QuantLib.new_TARGET()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TARGET
    __del__ = lambda self: None
TARGET_swigregister = _QuantLib.TARGET_swigregister
TARGET_swigregister(TARGET)

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

    def __init__(self):
        this = _QuantLib.new_Turkey()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Turkey
    __del__ = lambda self: None
Turkey_swigregister = _QuantLib.Turkey_swigregister
Turkey_swigregister(Turkey)

class Ukraine(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    USE = _QuantLib.Ukraine_USE

    def __init__(self, *args):
        this = _QuantLib.new_Ukraine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Ukraine
    __del__ = lambda self: None
Ukraine_swigregister = _QuantLib.Ukraine_swigregister
Ukraine_swigregister(Ukraine)

class UnitedKingdom(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.UnitedKingdom_Settlement
    Exchange = _QuantLib.UnitedKingdom_Exchange
    Metals = _QuantLib.UnitedKingdom_Metals

    def __init__(self, *args):
        this = _QuantLib.new_UnitedKingdom(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_UnitedKingdom
    __del__ = lambda self: None
UnitedKingdom_swigregister = _QuantLib.UnitedKingdom_swigregister
UnitedKingdom_swigregister(UnitedKingdom)

class UnitedStates(Calendar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Settlement = _QuantLib.UnitedStates_Settlement
    NYSE = _QuantLib.UnitedStates_NYSE
    GovernmentBond = _QuantLib.UnitedStates_GovernmentBond
    NERC = _QuantLib.UnitedStates_NERC
    LiborImpact = _QuantLib.UnitedStates_LiborImpact
    FederalReserve = _QuantLib.UnitedStates_FederalReserve

    def __init__(self, *args):
        this = _QuantLib.new_UnitedStates(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_UnitedStates
    __del__ = lambda self: None
UnitedStates_swigregister = _QuantLib.UnitedStates_swigregister
UnitedStates_swigregister(UnitedStates)

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

    def __init__(self):
        this = _QuantLib.new_NullCalendar()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NullCalendar
    __del__ = lambda self: None
NullCalendar_swigregister = _QuantLib.NullCalendar_swigregister
NullCalendar_swigregister(NullCalendar)

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

    def __init__(self):
        this = _QuantLib.new_WeekendsOnly()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_WeekendsOnly
    __del__ = lambda self: None
WeekendsOnly_swigregister = _QuantLib.WeekendsOnly_swigregister
WeekendsOnly_swigregister(WeekendsOnly)

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

    def __init__(self, *args):
        this = _QuantLib.new_JointCalendar(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_JointCalendar
    __del__ = lambda self: None
JointCalendar_swigregister = _QuantLib.JointCalendar_swigregister
JointCalendar_swigregister(JointCalendar)

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

    def __init__(self, name):
        this = _QuantLib.new_BespokeCalendar(name)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def addWeekend(self, arg2):
        return _QuantLib.BespokeCalendar_addWeekend(self, arg2)
    __swig_destroy__ = _QuantLib.delete_BespokeCalendar
    __del__ = lambda self: None
BespokeCalendar_swigregister = _QuantLib.BespokeCalendar_swigregister
BespokeCalendar_swigregister(BespokeCalendar)


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

def nullDouble():
    return _QuantLib.nullDouble()
nullDouble = _QuantLib.nullDouble
class DayCounter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def dayCount(self, 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
    __del__ = lambda self: None
DayCounter_swigregister = _QuantLib.DayCounter_swigregister
DayCounter_swigregister(DayCounter)

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

    def __init__(self):
        this = _QuantLib.new_Actual360()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Actual360
    __del__ = lambda self: None
Actual360_swigregister = _QuantLib.Actual360_swigregister
Actual360_swigregister(Actual360)

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

    def __init__(self, *args):
        this = _QuantLib.new_Actual365Fixed(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Actual365Fixed
    __del__ = lambda self: None
Actual365Fixed_swigregister = _QuantLib.Actual365Fixed_swigregister
Actual365Fixed_swigregister(Actual365Fixed)

class Thirty360(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    USA = _QuantLib.Thirty360_USA
    BondBasis = _QuantLib.Thirty360_BondBasis
    European = _QuantLib.Thirty360_European
    EurobondBasis = _QuantLib.Thirty360_EurobondBasis
    Italian = _QuantLib.Thirty360_Italian

    def __init__(self, *args):
        this = _QuantLib.new_Thirty360(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Thirty360
    __del__ = lambda self: None
Thirty360_swigregister = _QuantLib.Thirty360_swigregister
Thirty360_swigregister(Thirty360)

class ActualActual(DayCounter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ISMA = _QuantLib.ActualActual_ISMA
    Bond = _QuantLib.ActualActual_Bond
    ISDA = _QuantLib.ActualActual_ISDA
    Historical = _QuantLib.ActualActual_Historical
    Actual365 = _QuantLib.ActualActual_Actual365
    AFB = _QuantLib.ActualActual_AFB
    Euro = _QuantLib.ActualActual_Euro

    def __init__(self, *args):
        this = _QuantLib.new_ActualActual(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ActualActual
    __del__ = lambda self: None
ActualActual_swigregister = _QuantLib.ActualActual_swigregister
ActualActual_swigregister(ActualActual)

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

    def __init__(self):
        this = _QuantLib.new_OneDayCounter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_OneDayCounter
    __del__ = lambda self: None
OneDayCounter_swigregister = _QuantLib.OneDayCounter_swigregister
OneDayCounter_swigregister(OneDayCounter)

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

    def __init__(self):
        this = _QuantLib.new_SimpleDayCounter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SimpleDayCounter
    __del__ = lambda self: None
SimpleDayCounter_swigregister = _QuantLib.SimpleDayCounter_swigregister
SimpleDayCounter_swigregister(SimpleDayCounter)

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

    def __init__(self, *args):
        this = _QuantLib.new_Business252(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Business252
    __del__ = lambda self: None
Business252_swigregister = _QuantLib.Business252_swigregister
Business252_swigregister(Business252)


def Actual365NoLeap():
    return _QuantLib.Actual365NoLeap()
Actual365NoLeap = _QuantLib.Actual365NoLeap
Simple = _QuantLib.Simple
Compounded = _QuantLib.Compounded
Continuous = _QuantLib.Continuous
SimpleThenCompounded = _QuantLib.SimpleThenCompounded
CompoundedThenSimple = _QuantLib.CompoundedThenSimple
class InterestRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_InterestRate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def rate(self):
        return _QuantLib.InterestRate_rate(self)

    def dayCounter(self):
        return _QuantLib.InterestRate_dayCounter(self)

    def compounding(self):
        return _QuantLib.InterestRate_compounding(self)

    def frequency(self):
        return _QuantLib.InterestRate_frequency(self)

    def discountFactor(self, *args):
        return _QuantLib.InterestRate_discountFactor(self, *args)

    def compoundFactor(self, *args):
        return _QuantLib.InterestRate_compoundFactor(self, *args)
    impliedRate = staticmethod(_QuantLib.InterestRate_impliedRate)

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

    def __str__(self):
        return _QuantLib.InterestRate___str__(self)
    __swig_destroy__ = _QuantLib.delete_InterestRate
    __del__ = lambda self: None
InterestRate_swigregister = _QuantLib.InterestRate_swigregister
InterestRate_swigregister(InterestRate)

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

class InterestRateVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_InterestRateVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
InterestRateVector_swigregister = _QuantLib.InterestRateVector_swigregister
InterestRateVector_swigregister(InterestRateVector)

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

    def __init__(self):
        this = _QuantLib.new_Rounding()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, value):
        return _QuantLib.Rounding___call__(self, value)
    __swig_destroy__ = _QuantLib.delete_Rounding
    __del__ = lambda self: None
Rounding_swigregister = _QuantLib.Rounding_swigregister
Rounding_swigregister(Rounding)

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

    def __init__(self, precision, digit=5):
        this = _QuantLib.new_UpRounding(precision, digit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_UpRounding
    __del__ = lambda self: None
UpRounding_swigregister = _QuantLib.UpRounding_swigregister
UpRounding_swigregister(UpRounding)

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

    def __init__(self, precision, digit=5):
        this = _QuantLib.new_DownRounding(precision, digit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DownRounding
    __del__ = lambda self: None
DownRounding_swigregister = _QuantLib.DownRounding_swigregister
DownRounding_swigregister(DownRounding)

class ClosestRounding(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        this = _QuantLib.new_ClosestRounding(precision, digit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ClosestRounding
    __del__ = lambda self: None
ClosestRounding_swigregister = _QuantLib.ClosestRounding_swigregister
ClosestRounding_swigregister(ClosestRounding)

class CeilingTruncation(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        this = _QuantLib.new_CeilingTruncation(precision, digit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CeilingTruncation
    __del__ = lambda self: None
CeilingTruncation_swigregister = _QuantLib.CeilingTruncation_swigregister
CeilingTruncation_swigregister(CeilingTruncation)

class FloorTruncation(Rounding):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, precision, digit=5):
        this = _QuantLib.new_FloorTruncation(precision, digit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FloorTruncation
    __del__ = lambda self: None
FloorTruncation_swigregister = _QuantLib.FloorTruncation_swigregister
FloorTruncation_swigregister(FloorTruncation)

class Currency(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

    def code(self):
        return _QuantLib.Currency_code(self)

    def numericCode(self):
        return _QuantLib.Currency_numericCode(self)

    def symbol(self):
        return _QuantLib.Currency_symbol(self)

    def fractionSymbol(self):
        return _QuantLib.Currency_fractionSymbol(self)

    def fractionsPerUnit(self):
        return _QuantLib.Currency_fractionsPerUnit(self)

    def rounding(self):
        return _QuantLib.Currency_rounding(self)

    def format(self):
        return _QuantLib.Currency_format(self)

    def 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):
        this = _QuantLib.new_Currency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Currency
    __del__ = lambda self: None
Currency_swigregister = _QuantLib.Currency_swigregister
Currency_swigregister(Currency)

class ARSCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ARSCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ARSCurrency
    __del__ = lambda self: None
ARSCurrency_swigregister = _QuantLib.ARSCurrency_swigregister
ARSCurrency_swigregister(ARSCurrency)

class ATSCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ATSCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ATSCurrency
    __del__ = lambda self: None
ATSCurrency_swigregister = _QuantLib.ATSCurrency_swigregister
ATSCurrency_swigregister(ATSCurrency)

class AUDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_AUDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AUDCurrency
    __del__ = lambda self: None
AUDCurrency_swigregister = _QuantLib.AUDCurrency_swigregister
AUDCurrency_swigregister(AUDCurrency)

class BDTCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BDTCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BDTCurrency
    __del__ = lambda self: None
BDTCurrency_swigregister = _QuantLib.BDTCurrency_swigregister
BDTCurrency_swigregister(BDTCurrency)

class BEFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BEFCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BEFCurrency
    __del__ = lambda self: None
BEFCurrency_swigregister = _QuantLib.BEFCurrency_swigregister
BEFCurrency_swigregister(BEFCurrency)

class BGLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BGLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BGLCurrency
    __del__ = lambda self: None
BGLCurrency_swigregister = _QuantLib.BGLCurrency_swigregister
BGLCurrency_swigregister(BGLCurrency)

class BRLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BRLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BRLCurrency
    __del__ = lambda self: None
BRLCurrency_swigregister = _QuantLib.BRLCurrency_swigregister
BRLCurrency_swigregister(BRLCurrency)

class BYRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BYRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BYRCurrency
    __del__ = lambda self: None
BYRCurrency_swigregister = _QuantLib.BYRCurrency_swigregister
BYRCurrency_swigregister(BYRCurrency)

class CADCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CADCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CADCurrency
    __del__ = lambda self: None
CADCurrency_swigregister = _QuantLib.CADCurrency_swigregister
CADCurrency_swigregister(CADCurrency)

class CHFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CHFCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CHFCurrency
    __del__ = lambda self: None
CHFCurrency_swigregister = _QuantLib.CHFCurrency_swigregister
CHFCurrency_swigregister(CHFCurrency)

class CLPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CLPCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CLPCurrency
    __del__ = lambda self: None
CLPCurrency_swigregister = _QuantLib.CLPCurrency_swigregister
CLPCurrency_swigregister(CLPCurrency)

class CNYCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CNYCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CNYCurrency
    __del__ = lambda self: None
CNYCurrency_swigregister = _QuantLib.CNYCurrency_swigregister
CNYCurrency_swigregister(CNYCurrency)

class COPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_COPCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_COPCurrency
    __del__ = lambda self: None
COPCurrency_swigregister = _QuantLib.COPCurrency_swigregister
COPCurrency_swigregister(COPCurrency)

class CYPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CYPCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CYPCurrency
    __del__ = lambda self: None
CYPCurrency_swigregister = _QuantLib.CYPCurrency_swigregister
CYPCurrency_swigregister(CYPCurrency)

class CZKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CZKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CZKCurrency
    __del__ = lambda self: None
CZKCurrency_swigregister = _QuantLib.CZKCurrency_swigregister
CZKCurrency_swigregister(CZKCurrency)

class DEMCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_DEMCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DEMCurrency
    __del__ = lambda self: None
DEMCurrency_swigregister = _QuantLib.DEMCurrency_swigregister
DEMCurrency_swigregister(DEMCurrency)

class DKKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_DKKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DKKCurrency
    __del__ = lambda self: None
DKKCurrency_swigregister = _QuantLib.DKKCurrency_swigregister
DKKCurrency_swigregister(DKKCurrency)

class EEKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_EEKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EEKCurrency
    __del__ = lambda self: None
EEKCurrency_swigregister = _QuantLib.EEKCurrency_swigregister
EEKCurrency_swigregister(EEKCurrency)

class ESPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ESPCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ESPCurrency
    __del__ = lambda self: None
ESPCurrency_swigregister = _QuantLib.ESPCurrency_swigregister
ESPCurrency_swigregister(ESPCurrency)

class EURCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_EURCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURCurrency
    __del__ = lambda self: None
EURCurrency_swigregister = _QuantLib.EURCurrency_swigregister
EURCurrency_swigregister(EURCurrency)

class FIMCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_FIMCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FIMCurrency
    __del__ = lambda self: None
FIMCurrency_swigregister = _QuantLib.FIMCurrency_swigregister
FIMCurrency_swigregister(FIMCurrency)

class FRFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_FRFCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FRFCurrency
    __del__ = lambda self: None
FRFCurrency_swigregister = _QuantLib.FRFCurrency_swigregister
FRFCurrency_swigregister(FRFCurrency)

class GBPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_GBPCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GBPCurrency
    __del__ = lambda self: None
GBPCurrency_swigregister = _QuantLib.GBPCurrency_swigregister
GBPCurrency_swigregister(GBPCurrency)

class GRDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_GRDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GRDCurrency
    __del__ = lambda self: None
GRDCurrency_swigregister = _QuantLib.GRDCurrency_swigregister
GRDCurrency_swigregister(GRDCurrency)

class HKDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_HKDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HKDCurrency
    __del__ = lambda self: None
HKDCurrency_swigregister = _QuantLib.HKDCurrency_swigregister
HKDCurrency_swigregister(HKDCurrency)

class HUFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_HUFCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HUFCurrency
    __del__ = lambda self: None
HUFCurrency_swigregister = _QuantLib.HUFCurrency_swigregister
HUFCurrency_swigregister(HUFCurrency)

class IEPCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_IEPCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IEPCurrency
    __del__ = lambda self: None
IEPCurrency_swigregister = _QuantLib.IEPCurrency_swigregister
IEPCurrency_swigregister(IEPCurrency)

class IDRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_IDRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IDRCurrency
    __del__ = lambda self: None
IDRCurrency_swigregister = _QuantLib.IDRCurrency_swigregister
IDRCurrency_swigregister(IDRCurrency)

class ILSCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ILSCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ILSCurrency
    __del__ = lambda self: None
ILSCurrency_swigregister = _QuantLib.ILSCurrency_swigregister
ILSCurrency_swigregister(ILSCurrency)

class INRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_INRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_INRCurrency
    __del__ = lambda self: None
INRCurrency_swigregister = _QuantLib.INRCurrency_swigregister
INRCurrency_swigregister(INRCurrency)

class IQDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_IQDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IQDCurrency
    __del__ = lambda self: None
IQDCurrency_swigregister = _QuantLib.IQDCurrency_swigregister
IQDCurrency_swigregister(IQDCurrency)

class IRRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_IRRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IRRCurrency
    __del__ = lambda self: None
IRRCurrency_swigregister = _QuantLib.IRRCurrency_swigregister
IRRCurrency_swigregister(IRRCurrency)

class ISKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ISKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ISKCurrency
    __del__ = lambda self: None
ISKCurrency_swigregister = _QuantLib.ISKCurrency_swigregister
ISKCurrency_swigregister(ISKCurrency)

class ITLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ITLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ITLCurrency
    __del__ = lambda self: None
ITLCurrency_swigregister = _QuantLib.ITLCurrency_swigregister
ITLCurrency_swigregister(ITLCurrency)

class JPYCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_JPYCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_JPYCurrency
    __del__ = lambda self: None
JPYCurrency_swigregister = _QuantLib.JPYCurrency_swigregister
JPYCurrency_swigregister(JPYCurrency)

class KRWCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_KRWCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_KRWCurrency
    __del__ = lambda self: None
KRWCurrency_swigregister = _QuantLib.KRWCurrency_swigregister
KRWCurrency_swigregister(KRWCurrency)

class KWDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_KWDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_KWDCurrency
    __del__ = lambda self: None
KWDCurrency_swigregister = _QuantLib.KWDCurrency_swigregister
KWDCurrency_swigregister(KWDCurrency)

class LTLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_LTLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LTLCurrency
    __del__ = lambda self: None
LTLCurrency_swigregister = _QuantLib.LTLCurrency_swigregister
LTLCurrency_swigregister(LTLCurrency)

class LUFCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_LUFCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LUFCurrency
    __del__ = lambda self: None
LUFCurrency_swigregister = _QuantLib.LUFCurrency_swigregister
LUFCurrency_swigregister(LUFCurrency)

class LVLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_LVLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LVLCurrency
    __del__ = lambda self: None
LVLCurrency_swigregister = _QuantLib.LVLCurrency_swigregister
LVLCurrency_swigregister(LVLCurrency)

class MTLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_MTLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MTLCurrency
    __del__ = lambda self: None
MTLCurrency_swigregister = _QuantLib.MTLCurrency_swigregister
MTLCurrency_swigregister(MTLCurrency)

class MXNCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_MXNCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MXNCurrency
    __del__ = lambda self: None
MXNCurrency_swigregister = _QuantLib.MXNCurrency_swigregister
MXNCurrency_swigregister(MXNCurrency)

class MYRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_MYRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MYRCurrency
    __del__ = lambda self: None
MYRCurrency_swigregister = _QuantLib.MYRCurrency_swigregister
MYRCurrency_swigregister(MYRCurrency)

class NLGCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_NLGCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NLGCurrency
    __del__ = lambda self: None
NLGCurrency_swigregister = _QuantLib.NLGCurrency_swigregister
NLGCurrency_swigregister(NLGCurrency)

class NOKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_NOKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NOKCurrency
    __del__ = lambda self: None
NOKCurrency_swigregister = _QuantLib.NOKCurrency_swigregister
NOKCurrency_swigregister(NOKCurrency)

class NPRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_NPRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NPRCurrency
    __del__ = lambda self: None
NPRCurrency_swigregister = _QuantLib.NPRCurrency_swigregister
NPRCurrency_swigregister(NPRCurrency)

class NZDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_NZDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NZDCurrency
    __del__ = lambda self: None
NZDCurrency_swigregister = _QuantLib.NZDCurrency_swigregister
NZDCurrency_swigregister(NZDCurrency)

class PEHCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PEHCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PEHCurrency
    __del__ = lambda self: None
PEHCurrency_swigregister = _QuantLib.PEHCurrency_swigregister
PEHCurrency_swigregister(PEHCurrency)

class PEICurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PEICurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PEICurrency
    __del__ = lambda self: None
PEICurrency_swigregister = _QuantLib.PEICurrency_swigregister
PEICurrency_swigregister(PEICurrency)

class PENCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PENCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PENCurrency
    __del__ = lambda self: None
PENCurrency_swigregister = _QuantLib.PENCurrency_swigregister
PENCurrency_swigregister(PENCurrency)

class PKRCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PKRCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PKRCurrency
    __del__ = lambda self: None
PKRCurrency_swigregister = _QuantLib.PKRCurrency_swigregister
PKRCurrency_swigregister(PKRCurrency)

class PLNCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PLNCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PLNCurrency
    __del__ = lambda self: None
PLNCurrency_swigregister = _QuantLib.PLNCurrency_swigregister
PLNCurrency_swigregister(PLNCurrency)

class PTECurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PTECurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PTECurrency
    __del__ = lambda self: None
PTECurrency_swigregister = _QuantLib.PTECurrency_swigregister
PTECurrency_swigregister(PTECurrency)

class ROLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ROLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ROLCurrency
    __del__ = lambda self: None
ROLCurrency_swigregister = _QuantLib.ROLCurrency_swigregister
ROLCurrency_swigregister(ROLCurrency)

class RONCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_RONCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_RONCurrency
    __del__ = lambda self: None
RONCurrency_swigregister = _QuantLib.RONCurrency_swigregister
RONCurrency_swigregister(RONCurrency)

class RUBCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_RUBCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_RUBCurrency
    __del__ = lambda self: None
RUBCurrency_swigregister = _QuantLib.RUBCurrency_swigregister
RUBCurrency_swigregister(RUBCurrency)

class SARCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_SARCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SARCurrency
    __del__ = lambda self: None
SARCurrency_swigregister = _QuantLib.SARCurrency_swigregister
SARCurrency_swigregister(SARCurrency)

class SEKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_SEKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SEKCurrency
    __del__ = lambda self: None
SEKCurrency_swigregister = _QuantLib.SEKCurrency_swigregister
SEKCurrency_swigregister(SEKCurrency)

class SGDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_SGDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SGDCurrency
    __del__ = lambda self: None
SGDCurrency_swigregister = _QuantLib.SGDCurrency_swigregister
SGDCurrency_swigregister(SGDCurrency)

class SITCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_SITCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SITCurrency
    __del__ = lambda self: None
SITCurrency_swigregister = _QuantLib.SITCurrency_swigregister
SITCurrency_swigregister(SITCurrency)

class SKKCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_SKKCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SKKCurrency
    __del__ = lambda self: None
SKKCurrency_swigregister = _QuantLib.SKKCurrency_swigregister
SKKCurrency_swigregister(SKKCurrency)

class THBCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_THBCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_THBCurrency
    __del__ = lambda self: None
THBCurrency_swigregister = _QuantLib.THBCurrency_swigregister
THBCurrency_swigregister(THBCurrency)

class TRLCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_TRLCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TRLCurrency
    __del__ = lambda self: None
TRLCurrency_swigregister = _QuantLib.TRLCurrency_swigregister
TRLCurrency_swigregister(TRLCurrency)

class TRYCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_TRYCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TRYCurrency
    __del__ = lambda self: None
TRYCurrency_swigregister = _QuantLib.TRYCurrency_swigregister
TRYCurrency_swigregister(TRYCurrency)

class TTDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_TTDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TTDCurrency
    __del__ = lambda self: None
TTDCurrency_swigregister = _QuantLib.TTDCurrency_swigregister
TTDCurrency_swigregister(TTDCurrency)

class TWDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_TWDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TWDCurrency
    __del__ = lambda self: None
TWDCurrency_swigregister = _QuantLib.TWDCurrency_swigregister
TWDCurrency_swigregister(TWDCurrency)

class USDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_USDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_USDCurrency
    __del__ = lambda self: None
USDCurrency_swigregister = _QuantLib.USDCurrency_swigregister
USDCurrency_swigregister(USDCurrency)

class VEBCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_VEBCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_VEBCurrency
    __del__ = lambda self: None
VEBCurrency_swigregister = _QuantLib.VEBCurrency_swigregister
VEBCurrency_swigregister(VEBCurrency)

class VNDCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_VNDCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_VNDCurrency
    __del__ = lambda self: None
VNDCurrency_swigregister = _QuantLib.VNDCurrency_swigregister
VNDCurrency_swigregister(VNDCurrency)

class ZARCurrency(Currency):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ZARCurrency()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZARCurrency
    __del__ = lambda self: None
ZARCurrency_swigregister = _QuantLib.ZARCurrency_swigregister
ZARCurrency_swigregister(ZARCurrency)

class LinearInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_LinearInterpolation(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.LinearInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_LinearInterpolation
    __del__ = lambda self: None
LinearInterpolation_swigregister = _QuantLib.LinearInterpolation_swigregister
LinearInterpolation_swigregister(LinearInterpolation)

class LogLinearInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_LogLinearInterpolation(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.LogLinearInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_LogLinearInterpolation
    __del__ = lambda self: None
LogLinearInterpolation_swigregister = _QuantLib.LogLinearInterpolation_swigregister
LogLinearInterpolation_swigregister(LogLinearInterpolation)

class BackwardFlatInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_BackwardFlatInterpolation(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.BackwardFlatInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BackwardFlatInterpolation
    __del__ = lambda self: None
BackwardFlatInterpolation_swigregister = _QuantLib.BackwardFlatInterpolation_swigregister
BackwardFlatInterpolation_swigregister(BackwardFlatInterpolation)

class ForwardFlatInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_ForwardFlatInterpolation(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, allowExtrapolation=False):
        return _QuantLib.ForwardFlatInterpolation___call__(self, x, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_ForwardFlatInterpolation
    __del__ = lambda self: None
ForwardFlatInterpolation_swigregister = _QuantLib.ForwardFlatInterpolation_swigregister
ForwardFlatInterpolation_swigregister(ForwardFlatInterpolation)

class CubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_CubicNaturalSpline(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CubicNaturalSpline_swigregister = _QuantLib.CubicNaturalSpline_swigregister
CubicNaturalSpline_swigregister(CubicNaturalSpline)

class LogCubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_LogCubicNaturalSpline(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
LogCubicNaturalSpline_swigregister = _QuantLib.LogCubicNaturalSpline_swigregister
LogCubicNaturalSpline_swigregister(LogCubicNaturalSpline)

class MonotonicCubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_MonotonicCubicNaturalSpline(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
MonotonicCubicNaturalSpline_swigregister = _QuantLib.MonotonicCubicNaturalSpline_swigregister
MonotonicCubicNaturalSpline_swigregister(MonotonicCubicNaturalSpline)

class MonotonicLogCubicNaturalSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_MonotonicLogCubicNaturalSpline(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
MonotonicLogCubicNaturalSpline_swigregister = _QuantLib.MonotonicLogCubicNaturalSpline_swigregister
MonotonicLogCubicNaturalSpline_swigregister(MonotonicLogCubicNaturalSpline)

class KrugerCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_KrugerCubic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
KrugerCubic_swigregister = _QuantLib.KrugerCubic_swigregister
KrugerCubic_swigregister(KrugerCubic)

class KrugerLogCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_KrugerLogCubic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
KrugerLogCubic_swigregister = _QuantLib.KrugerLogCubic_swigregister
KrugerLogCubic_swigregister(KrugerLogCubic)

class FritschButlandCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_FritschButlandCubic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
FritschButlandCubic_swigregister = _QuantLib.FritschButlandCubic_swigregister
FritschButlandCubic_swigregister(FritschButlandCubic)

class FritschButlandLogCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_FritschButlandLogCubic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
FritschButlandLogCubic_swigregister = _QuantLib.FritschButlandLogCubic_swigregister
FritschButlandLogCubic_swigregister(FritschButlandLogCubic)

class Parabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_Parabolic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Parabolic_swigregister = _QuantLib.Parabolic_swigregister
Parabolic_swigregister(Parabolic)

class LogParabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_LogParabolic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
LogParabolic_swigregister = _QuantLib.LogParabolic_swigregister
LogParabolic_swigregister(LogParabolic)

class MonotonicParabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_MonotonicParabolic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
MonotonicParabolic_swigregister = _QuantLib.MonotonicParabolic_swigregister
MonotonicParabolic_swigregister(MonotonicParabolic)

class MonotonicLogParabolic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y):
        this = _QuantLib.new_MonotonicLogParabolic(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
MonotonicLogParabolic_swigregister = _QuantLib.MonotonicLogParabolic_swigregister
MonotonicLogParabolic_swigregister(MonotonicLogParabolic)

class BilinearInterpolation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y, m):
        this = _QuantLib.new_BilinearInterpolation(x, y, m)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, y, allowExtrapolation=False):
        return _QuantLib.BilinearInterpolation___call__(self, x, y, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BilinearInterpolation
    __del__ = lambda self: None
BilinearInterpolation_swigregister = _QuantLib.BilinearInterpolation_swigregister
BilinearInterpolation_swigregister(BilinearInterpolation)

class BicubicSpline(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, x, y, m):
        this = _QuantLib.new_BicubicSpline(x, y, m)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, y, allowExtrapolation=False):
        return _QuantLib.BicubicSpline___call__(self, x, y, allowExtrapolation)
    __swig_destroy__ = _QuantLib.delete_BicubicSpline
    __del__ = lambda self: None
BicubicSpline_swigregister = _QuantLib.BicubicSpline_swigregister
BicubicSpline_swigregister(BicubicSpline)

class BackwardFlat(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BackwardFlat()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BackwardFlat
    __del__ = lambda self: None
BackwardFlat_swigregister = _QuantLib.BackwardFlat_swigregister
BackwardFlat_swigregister(BackwardFlat)

class ForwardFlat(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ForwardFlat()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardFlat
    __del__ = lambda self: None
ForwardFlat_swigregister = _QuantLib.ForwardFlat_swigregister
ForwardFlat_swigregister(ForwardFlat)

class Linear(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_Linear()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Linear
    __del__ = lambda self: None
Linear_swigregister = _QuantLib.Linear_swigregister
Linear_swigregister(Linear)

class LogLinear(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_LogLinear()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LogLinear
    __del__ = lambda self: None
LogLinear_swigregister = _QuantLib.LogLinear_swigregister
LogLinear_swigregister(LogLinear)

class Cubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_Cubic()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Cubic
    __del__ = lambda self: None
Cubic_swigregister = _QuantLib.Cubic_swigregister
Cubic_swigregister(Cubic)

class MonotonicCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_MonotonicCubic()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MonotonicCubic
    __del__ = lambda self: None
MonotonicCubic_swigregister = _QuantLib.MonotonicCubic_swigregister
MonotonicCubic_swigregister(MonotonicCubic)

class DefaultLogCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_DefaultLogCubic()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultLogCubic
    __del__ = lambda self: None
DefaultLogCubic_swigregister = _QuantLib.DefaultLogCubic_swigregister
DefaultLogCubic_swigregister(DefaultLogCubic)

class MonotonicLogCubic(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_MonotonicLogCubic()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MonotonicLogCubic
    __del__ = lambda self: None
MonotonicLogCubic_swigregister = _QuantLib.MonotonicLogCubic_swigregister
MonotonicLogCubic_swigregister(MonotonicLogCubic)

class YieldTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.YieldTermStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_YieldTermStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YieldTermStructure
    __del__ = lambda self: None

    def dayCounter(self):
        return _QuantLib.YieldTermStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.YieldTermStructure_calendar(self)

    def referenceDate(self):
        return _QuantLib.YieldTermStructure_referenceDate(self)

    def maxDate(self):
        return _QuantLib.YieldTermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.YieldTermStructure_maxTime(self)

    def discount(self, *args):
        return _QuantLib.YieldTermStructure_discount(self, *args)

    def zeroRate(self, *args):
        return _QuantLib.YieldTermStructure_zeroRate(self, *args)

    def forwardRate(self, *args):
        return _QuantLib.YieldTermStructure_forwardRate(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.YieldTermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YieldTermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YieldTermStructure_allowsExtrapolation(self)
YieldTermStructure_swigregister = _QuantLib.YieldTermStructure_swigregister
YieldTermStructure_swigregister(YieldTermStructure)

class YieldTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YieldTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.YieldTermStructureHandle___deref__(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
    __del__ = lambda self: None

    def dayCounter(self):
        return _QuantLib.YieldTermStructureHandle_dayCounter(self)

    def calendar(self):
        return _QuantLib.YieldTermStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.YieldTermStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.YieldTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.YieldTermStructureHandle_maxTime(self)

    def discount(self, *args):
        return _QuantLib.YieldTermStructureHandle_discount(self, *args)

    def zeroRate(self, *args):
        return _QuantLib.YieldTermStructureHandle_zeroRate(self, *args)

    def forwardRate(self, *args):
        return _QuantLib.YieldTermStructureHandle_forwardRate(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.YieldTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YieldTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YieldTermStructureHandle_allowsExtrapolation(self)
YieldTermStructureHandle_swigregister = _QuantLib.YieldTermStructureHandle_swigregister
YieldTermStructureHandle_swigregister(YieldTermStructureHandle)

class RelinkableYieldTermStructureHandle(YieldTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableYieldTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableYieldTermStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableYieldTermStructureHandle
    __del__ = lambda self: None
RelinkableYieldTermStructureHandle_swigregister = _QuantLib.RelinkableYieldTermStructureHandle_swigregister
RelinkableYieldTermStructureHandle_swigregister(RelinkableYieldTermStructureHandle)

class ImpliedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, curveHandle, referenceDate):
        this = _QuantLib.new_ImpliedTermStructure(curveHandle, referenceDate)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ImpliedTermStructure
    __del__ = lambda self: None
ImpliedTermStructure_swigregister = _QuantLib.ImpliedTermStructure_swigregister
ImpliedTermStructure_swigregister(ImpliedTermStructure)

class ZeroSpreadedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ZeroSpreadedTermStructure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroSpreadedTermStructure
    __del__ = lambda self: None
ZeroSpreadedTermStructure_swigregister = _QuantLib.ZeroSpreadedTermStructure_swigregister
ZeroSpreadedTermStructure_swigregister(ZeroSpreadedTermStructure)

class ForwardSpreadedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, curveHandle, spreadHandle):
        this = _QuantLib.new_ForwardSpreadedTermStructure(curveHandle, spreadHandle)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardSpreadedTermStructure
    __del__ = lambda self: None
ForwardSpreadedTermStructure_swigregister = _QuantLib.ForwardSpreadedTermStructure_swigregister
ForwardSpreadedTermStructure_swigregister(ForwardSpreadedTermStructure)

class SpreadedLinearZeroInterpolatedTermStructure(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SpreadedLinearZeroInterpolatedTermStructure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SpreadedLinearZeroInterpolatedTermStructure
    __del__ = lambda self: None
SpreadedLinearZeroInterpolatedTermStructure_swigregister = _QuantLib.SpreadedLinearZeroInterpolatedTermStructure_swigregister
SpreadedLinearZeroInterpolatedTermStructure_swigregister(SpreadedLinearZeroInterpolatedTermStructure)

class FlatForward(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FlatForward(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FlatForward
    __del__ = lambda self: None
FlatForward_swigregister = _QuantLib.FlatForward_swigregister
FlatForward_swigregister(FlatForward)

class RealTimeSeries(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RealTimeSeries(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def values(self):
        return _QuantLib.RealTimeSeries_values(self)

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

    def __getitem__(self, d):
        return _QuantLib.RealTimeSeries___getitem__(self, d)

    def __setitem__(self, d, value):
        return _QuantLib.RealTimeSeries___setitem__(self, d, value)
    __swig_destroy__ = _QuantLib.delete_RealTimeSeries
    __del__ = lambda self: None
RealTimeSeries_swigregister = _QuantLib.RealTimeSeries_swigregister
RealTimeSeries_swigregister(RealTimeSeries)

class IntervalPriceTimeSeries(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_IntervalPriceTimeSeries(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def values(self):
        return _QuantLib.IntervalPriceTimeSeries_values(self)

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

    def __getitem__(self, d):
        return _QuantLib.IntervalPriceTimeSeries___getitem__(self, d)

    def __setitem__(self, d, value):
        return _QuantLib.IntervalPriceTimeSeries___setitem__(self, d, value)
    __swig_destroy__ = _QuantLib.delete_IntervalPriceTimeSeries
    __del__ = lambda self: None
IntervalPriceTimeSeries_swigregister = _QuantLib.IntervalPriceTimeSeries_swigregister
IntervalPriceTimeSeries_swigregister(IntervalPriceTimeSeries)

class IntervalPriceVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.IntervalPriceVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_IntervalPriceVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
IntervalPriceVector_swigregister = _QuantLib.IntervalPriceVector_swigregister
IntervalPriceVector_swigregister(IntervalPriceVector)

class IntervalPrice(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Open = _QuantLib.IntervalPrice_Open
    Close = _QuantLib.IntervalPrice_Close
    High = _QuantLib.IntervalPrice_High
    Low = _QuantLib.IntervalPrice_Low

    def __init__(self, arg2, arg3, arg4, arg5):
        this = _QuantLib.new_IntervalPrice(arg2, arg3, arg4, arg5)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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)
    makeSeries = staticmethod(_QuantLib.IntervalPrice_makeSeries)
    extractValues = staticmethod(_QuantLib.IntervalPrice_extractValues)
    extractComponent = staticmethod(_QuantLib.IntervalPrice_extractComponent)
    __swig_destroy__ = _QuantLib.delete_IntervalPrice
    __del__ = lambda self: None
IntervalPrice_swigregister = _QuantLib.IntervalPrice_swigregister
IntervalPrice_swigregister(IntervalPrice)

def IntervalPrice_makeSeries(d, open, close, high, low):
    return _QuantLib.IntervalPrice_makeSeries(d, open, close, high, low)
IntervalPrice_makeSeries = _QuantLib.IntervalPrice_makeSeries

def IntervalPrice_extractValues(arg2, t):
    return _QuantLib.IntervalPrice_extractValues(arg2, t)
IntervalPrice_extractValues = _QuantLib.IntervalPrice_extractValues

def IntervalPrice_extractComponent(arg2, t):
    return _QuantLib.IntervalPrice_extractComponent(arg2, t)
IntervalPrice_extractComponent = _QuantLib.IntervalPrice_extractComponent

class IndexManager(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    instance = staticmethod(_QuantLib.IndexManager_instance)

    def setHistory(self, 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
    __del__ = lambda self: None
IndexManager_swigregister = _QuantLib.IndexManager_swigregister
IndexManager_swigregister(IndexManager)

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

class Index(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def addFixings(self, fixingDates, fixings):
        return _QuantLib.Index_addFixings(self, fixingDates, fixings)

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

    def asObservable(self):
        return _QuantLib.Index_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_Index()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Index
    __del__ = lambda self: None

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

    def fixingCalendar(self):
        return _QuantLib.Index_fixingCalendar(self)

    def isValidFixingDate(self, 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):
        return _QuantLib.Index_addFixing(self, fixingDate, fixing)
Index_swigregister = _QuantLib.Index_swigregister
Index_swigregister(Index)

class InterestRateIndex(Index):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def familyName(self):
        return _QuantLib.InterestRateIndex_familyName(self)

    def tenor(self):
        return _QuantLib.InterestRateIndex_tenor(self)

    def fixingDays(self):
        return _QuantLib.InterestRateIndex_fixingDays(self)

    def fixingDate(self, 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
    __del__ = lambda self: None
InterestRateIndex_swigregister = _QuantLib.InterestRateIndex_swigregister
InterestRateIndex_swigregister(InterestRateIndex)

class IborIndex(InterestRateIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_IborIndex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def businessDayConvention(self):
        return _QuantLib.IborIndex_businessDayConvention(self)

    def endOfMonth(self):
        return _QuantLib.IborIndex_endOfMonth(self)

    def forwardingTermStructure(self):
        return _QuantLib.IborIndex_forwardingTermStructure(self)

    def clone(self, h):
        return _QuantLib.IborIndex_clone(self, h)
    __swig_destroy__ = _QuantLib.delete_IborIndex
    __del__ = lambda self: None
IborIndex_swigregister = _QuantLib.IborIndex_swigregister
IborIndex_swigregister(IborIndex)


def as_iborindex(index):
    return _QuantLib.as_iborindex(index)
as_iborindex = _QuantLib.as_iborindex
class OvernightIndex(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_OvernightIndex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_OvernightIndex
    __del__ = lambda self: None
OvernightIndex_swigregister = _QuantLib.OvernightIndex_swigregister
OvernightIndex_swigregister(OvernightIndex)

class Libor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Libor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Libor
    __del__ = lambda self: None
Libor_swigregister = _QuantLib.Libor_swigregister
Libor_swigregister(Libor)

class SwapIndex(InterestRateIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SwapIndex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fixedLegTenor(self):
        return _QuantLib.SwapIndex_fixedLegTenor(self)

    def fixedLegConvention(self):
        return _QuantLib.SwapIndex_fixedLegConvention(self)

    def iborIndex(self):
        return _QuantLib.SwapIndex_iborIndex(self)

    def forwardingTermStructure(self):
        return _QuantLib.SwapIndex_forwardingTermStructure(self)
    __swig_destroy__ = _QuantLib.delete_SwapIndex
    __del__ = lambda self: None
SwapIndex_swigregister = _QuantLib.SwapIndex_swigregister
SwapIndex_swigregister(SwapIndex)

class AUDLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_AUDLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AUDLibor
    __del__ = lambda self: None
AUDLibor_swigregister = _QuantLib.AUDLibor_swigregister
AUDLibor_swigregister(AUDLibor)

class CADLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CADLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CADLibor
    __del__ = lambda self: None
CADLibor_swigregister = _QuantLib.CADLibor_swigregister
CADLibor_swigregister(CADLibor)

class Cdor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Cdor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Cdor
    __del__ = lambda self: None
Cdor_swigregister = _QuantLib.Cdor_swigregister
Cdor_swigregister(Cdor)

class CHFLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CHFLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CHFLibor
    __del__ = lambda self: None
CHFLibor_swigregister = _QuantLib.CHFLibor_swigregister
CHFLibor_swigregister(CHFLibor)

class DKKLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DKKLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DKKLibor
    __del__ = lambda self: None
DKKLibor_swigregister = _QuantLib.DKKLibor_swigregister
DKKLibor_swigregister(DKKLibor)

class Bbsw(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw
    __del__ = lambda self: None
Bbsw_swigregister = _QuantLib.Bbsw_swigregister
Bbsw_swigregister(Bbsw)

class Bbsw1M(Bbsw):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw1M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw1M
    __del__ = lambda self: None
Bbsw1M_swigregister = _QuantLib.Bbsw1M_swigregister
Bbsw1M_swigregister(Bbsw1M)

class Bbsw2M(Bbsw):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw2M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw2M
    __del__ = lambda self: None
Bbsw2M_swigregister = _QuantLib.Bbsw2M_swigregister
Bbsw2M_swigregister(Bbsw2M)

class Bbsw3M(Bbsw):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw3M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw3M
    __del__ = lambda self: None
Bbsw3M_swigregister = _QuantLib.Bbsw3M_swigregister
Bbsw3M_swigregister(Bbsw3M)

class Bbsw4M(Bbsw):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw4M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw4M
    __del__ = lambda self: None
Bbsw4M_swigregister = _QuantLib.Bbsw4M_swigregister
Bbsw4M_swigregister(Bbsw4M)

class Bbsw5M(Bbsw):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw5M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw5M
    __del__ = lambda self: None
Bbsw5M_swigregister = _QuantLib.Bbsw5M_swigregister
Bbsw5M_swigregister(Bbsw5M)

class Bbsw6M(Bbsw):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bbsw6M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bbsw6M
    __del__ = lambda self: None
Bbsw6M_swigregister = _QuantLib.Bbsw6M_swigregister
Bbsw6M_swigregister(Bbsw6M)

class Bkbm(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm
    __del__ = lambda self: None
Bkbm_swigregister = _QuantLib.Bkbm_swigregister
Bkbm_swigregister(Bkbm)

class Bkbm1M(Bkbm):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm1M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm1M
    __del__ = lambda self: None
Bkbm1M_swigregister = _QuantLib.Bkbm1M_swigregister
Bkbm1M_swigregister(Bkbm1M)

class Bkbm2M(Bkbm):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm2M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm2M
    __del__ = lambda self: None
Bkbm2M_swigregister = _QuantLib.Bkbm2M_swigregister
Bkbm2M_swigregister(Bkbm2M)

class Bkbm3M(Bkbm):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm3M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm3M
    __del__ = lambda self: None
Bkbm3M_swigregister = _QuantLib.Bkbm3M_swigregister
Bkbm3M_swigregister(Bkbm3M)

class Bkbm4M(Bkbm):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm4M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm4M
    __del__ = lambda self: None
Bkbm4M_swigregister = _QuantLib.Bkbm4M_swigregister
Bkbm4M_swigregister(Bkbm4M)

class Bkbm5M(Bkbm):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm5M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm5M
    __del__ = lambda self: None
Bkbm5M_swigregister = _QuantLib.Bkbm5M_swigregister
Bkbm5M_swigregister(Bkbm5M)

class Bkbm6M(Bkbm):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bkbm6M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bkbm6M
    __del__ = lambda self: None
Bkbm6M_swigregister = _QuantLib.Bkbm6M_swigregister
Bkbm6M_swigregister(Bkbm6M)

class Euribor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor
    __del__ = lambda self: None
Euribor_swigregister = _QuantLib.Euribor_swigregister
Euribor_swigregister(Euribor)

class EuriborSW(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EuriborSW(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSW
    __del__ = lambda self: None
EuriborSW_swigregister = _QuantLib.EuriborSW_swigregister
EuriborSW_swigregister(EuriborSW)

class Euribor2W(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor2W(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor2W
    __del__ = lambda self: None
Euribor2W_swigregister = _QuantLib.Euribor2W_swigregister
Euribor2W_swigregister(Euribor2W)

class Euribor3W(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor3W(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor3W
    __del__ = lambda self: None
Euribor3W_swigregister = _QuantLib.Euribor3W_swigregister
Euribor3W_swigregister(Euribor3W)

class Euribor1M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor1M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor1M
    __del__ = lambda self: None
Euribor1M_swigregister = _QuantLib.Euribor1M_swigregister
Euribor1M_swigregister(Euribor1M)

class Euribor2M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor2M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor2M
    __del__ = lambda self: None
Euribor2M_swigregister = _QuantLib.Euribor2M_swigregister
Euribor2M_swigregister(Euribor2M)

class Euribor3M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor3M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor3M
    __del__ = lambda self: None
Euribor3M_swigregister = _QuantLib.Euribor3M_swigregister
Euribor3M_swigregister(Euribor3M)

class Euribor4M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor4M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor4M
    __del__ = lambda self: None
Euribor4M_swigregister = _QuantLib.Euribor4M_swigregister
Euribor4M_swigregister(Euribor4M)

class Euribor5M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor5M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor5M
    __del__ = lambda self: None
Euribor5M_swigregister = _QuantLib.Euribor5M_swigregister
Euribor5M_swigregister(Euribor5M)

class Euribor6M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor6M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor6M
    __del__ = lambda self: None
Euribor6M_swigregister = _QuantLib.Euribor6M_swigregister
Euribor6M_swigregister(Euribor6M)

class Euribor7M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor7M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor7M
    __del__ = lambda self: None
Euribor7M_swigregister = _QuantLib.Euribor7M_swigregister
Euribor7M_swigregister(Euribor7M)

class Euribor8M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor8M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor8M
    __del__ = lambda self: None
Euribor8M_swigregister = _QuantLib.Euribor8M_swigregister
Euribor8M_swigregister(Euribor8M)

class Euribor9M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor9M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor9M
    __del__ = lambda self: None
Euribor9M_swigregister = _QuantLib.Euribor9M_swigregister
Euribor9M_swigregister(Euribor9M)

class Euribor10M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor10M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor10M
    __del__ = lambda self: None
Euribor10M_swigregister = _QuantLib.Euribor10M_swigregister
Euribor10M_swigregister(Euribor10M)

class Euribor11M(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor11M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor11M
    __del__ = lambda self: None
Euribor11M_swigregister = _QuantLib.Euribor11M_swigregister
Euribor11M_swigregister(Euribor11M)

class Euribor1Y(Euribor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor1Y(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor1Y
    __del__ = lambda self: None
Euribor1Y_swigregister = _QuantLib.Euribor1Y_swigregister
Euribor1Y_swigregister(Euribor1Y)

class Euribor365(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365
    __del__ = lambda self: None
Euribor365_swigregister = _QuantLib.Euribor365_swigregister
Euribor365_swigregister(Euribor365)

class Euribor365_SW(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_SW(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_SW
    __del__ = lambda self: None
Euribor365_SW_swigregister = _QuantLib.Euribor365_SW_swigregister
Euribor365_SW_swigregister(Euribor365_SW)

class Euribor365_2W(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_2W(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_2W
    __del__ = lambda self: None
Euribor365_2W_swigregister = _QuantLib.Euribor365_2W_swigregister
Euribor365_2W_swigregister(Euribor365_2W)

class Euribor365_3W(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_3W(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_3W
    __del__ = lambda self: None
Euribor365_3W_swigregister = _QuantLib.Euribor365_3W_swigregister
Euribor365_3W_swigregister(Euribor365_3W)

class Euribor365_1M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_1M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_1M
    __del__ = lambda self: None
Euribor365_1M_swigregister = _QuantLib.Euribor365_1M_swigregister
Euribor365_1M_swigregister(Euribor365_1M)

class Euribor365_2M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_2M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_2M
    __del__ = lambda self: None
Euribor365_2M_swigregister = _QuantLib.Euribor365_2M_swigregister
Euribor365_2M_swigregister(Euribor365_2M)

class Euribor365_3M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_3M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_3M
    __del__ = lambda self: None
Euribor365_3M_swigregister = _QuantLib.Euribor365_3M_swigregister
Euribor365_3M_swigregister(Euribor365_3M)

class Euribor365_4M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_4M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_4M
    __del__ = lambda self: None
Euribor365_4M_swigregister = _QuantLib.Euribor365_4M_swigregister
Euribor365_4M_swigregister(Euribor365_4M)

class Euribor365_5M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_5M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_5M
    __del__ = lambda self: None
Euribor365_5M_swigregister = _QuantLib.Euribor365_5M_swigregister
Euribor365_5M_swigregister(Euribor365_5M)

class Euribor365_6M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_6M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_6M
    __del__ = lambda self: None
Euribor365_6M_swigregister = _QuantLib.Euribor365_6M_swigregister
Euribor365_6M_swigregister(Euribor365_6M)

class Euribor365_7M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_7M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_7M
    __del__ = lambda self: None
Euribor365_7M_swigregister = _QuantLib.Euribor365_7M_swigregister
Euribor365_7M_swigregister(Euribor365_7M)

class Euribor365_8M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_8M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_8M
    __del__ = lambda self: None
Euribor365_8M_swigregister = _QuantLib.Euribor365_8M_swigregister
Euribor365_8M_swigregister(Euribor365_8M)

class Euribor365_9M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_9M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_9M
    __del__ = lambda self: None
Euribor365_9M_swigregister = _QuantLib.Euribor365_9M_swigregister
Euribor365_9M_swigregister(Euribor365_9M)

class Euribor365_10M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_10M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_10M
    __del__ = lambda self: None
Euribor365_10M_swigregister = _QuantLib.Euribor365_10M_swigregister
Euribor365_10M_swigregister(Euribor365_10M)

class Euribor365_11M(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_11M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_11M
    __del__ = lambda self: None
Euribor365_11M_swigregister = _QuantLib.Euribor365_11M_swigregister
Euribor365_11M_swigregister(Euribor365_11M)

class Euribor365_1Y(Euribor365):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Euribor365_1Y(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Euribor365_1Y
    __del__ = lambda self: None
Euribor365_1Y_swigregister = _QuantLib.Euribor365_1Y_swigregister
Euribor365_1Y_swigregister(Euribor365_1Y)

class EURLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor
    __del__ = lambda self: None
EURLibor_swigregister = _QuantLib.EURLibor_swigregister
EURLibor_swigregister(EURLibor)

class EURLiborSW(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLiborSW(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLiborSW
    __del__ = lambda self: None
EURLiborSW_swigregister = _QuantLib.EURLiborSW_swigregister
EURLiborSW_swigregister(EURLiborSW)

class EURLibor2W(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor2W(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor2W
    __del__ = lambda self: None
EURLibor2W_swigregister = _QuantLib.EURLibor2W_swigregister
EURLibor2W_swigregister(EURLibor2W)

class EURLibor1M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor1M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor1M
    __del__ = lambda self: None
EURLibor1M_swigregister = _QuantLib.EURLibor1M_swigregister
EURLibor1M_swigregister(EURLibor1M)

class EURLibor2M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor2M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor2M
    __del__ = lambda self: None
EURLibor2M_swigregister = _QuantLib.EURLibor2M_swigregister
EURLibor2M_swigregister(EURLibor2M)

class EURLibor3M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor3M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor3M
    __del__ = lambda self: None
EURLibor3M_swigregister = _QuantLib.EURLibor3M_swigregister
EURLibor3M_swigregister(EURLibor3M)

class EURLibor4M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor4M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor4M
    __del__ = lambda self: None
EURLibor4M_swigregister = _QuantLib.EURLibor4M_swigregister
EURLibor4M_swigregister(EURLibor4M)

class EURLibor5M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor5M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor5M
    __del__ = lambda self: None
EURLibor5M_swigregister = _QuantLib.EURLibor5M_swigregister
EURLibor5M_swigregister(EURLibor5M)

class EURLibor6M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor6M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor6M
    __del__ = lambda self: None
EURLibor6M_swigregister = _QuantLib.EURLibor6M_swigregister
EURLibor6M_swigregister(EURLibor6M)

class EURLibor7M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor7M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor7M
    __del__ = lambda self: None
EURLibor7M_swigregister = _QuantLib.EURLibor7M_swigregister
EURLibor7M_swigregister(EURLibor7M)

class EURLibor8M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor8M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor8M
    __del__ = lambda self: None
EURLibor8M_swigregister = _QuantLib.EURLibor8M_swigregister
EURLibor8M_swigregister(EURLibor8M)

class EURLibor9M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor9M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor9M
    __del__ = lambda self: None
EURLibor9M_swigregister = _QuantLib.EURLibor9M_swigregister
EURLibor9M_swigregister(EURLibor9M)

class EURLibor10M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor10M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor10M
    __del__ = lambda self: None
EURLibor10M_swigregister = _QuantLib.EURLibor10M_swigregister
EURLibor10M_swigregister(EURLibor10M)

class EURLibor11M(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor11M(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor11M
    __del__ = lambda self: None
EURLibor11M_swigregister = _QuantLib.EURLibor11M_swigregister
EURLibor11M_swigregister(EURLibor11M)

class EURLibor1Y(EURLibor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EURLibor1Y(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EURLibor1Y
    __del__ = lambda self: None
EURLibor1Y_swigregister = _QuantLib.EURLibor1Y_swigregister
EURLibor1Y_swigregister(EURLibor1Y)

class GBPLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_GBPLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GBPLibor
    __del__ = lambda self: None
GBPLibor_swigregister = _QuantLib.GBPLibor_swigregister
GBPLibor_swigregister(GBPLibor)

class Jibar(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Jibar(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Jibar
    __del__ = lambda self: None
Jibar_swigregister = _QuantLib.Jibar_swigregister
Jibar_swigregister(Jibar)

class JPYLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_JPYLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_JPYLibor
    __del__ = lambda self: None
JPYLibor_swigregister = _QuantLib.JPYLibor_swigregister
JPYLibor_swigregister(JPYLibor)

class NZDLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_NZDLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NZDLibor
    __del__ = lambda self: None
NZDLibor_swigregister = _QuantLib.NZDLibor_swigregister
NZDLibor_swigregister(NZDLibor)

class SEKLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SEKLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SEKLibor
    __del__ = lambda self: None
SEKLibor_swigregister = _QuantLib.SEKLibor_swigregister
SEKLibor_swigregister(SEKLibor)

class Tibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Tibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Tibor
    __del__ = lambda self: None
Tibor_swigregister = _QuantLib.Tibor_swigregister
Tibor_swigregister(Tibor)

class TRLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_TRLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TRLibor
    __del__ = lambda self: None
TRLibor_swigregister = _QuantLib.TRLibor_swigregister
TRLibor_swigregister(TRLibor)

class USDLibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_USDLibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_USDLibor
    __del__ = lambda self: None
USDLibor_swigregister = _QuantLib.USDLibor_swigregister
USDLibor_swigregister(USDLibor)

class Zibor(IborIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Zibor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Zibor
    __del__ = lambda self: None
Zibor_swigregister = _QuantLib.Zibor_swigregister
Zibor_swigregister(Zibor)

class Aonia(OvernightIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Aonia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Aonia
    __del__ = lambda self: None
Aonia_swigregister = _QuantLib.Aonia_swigregister
Aonia_swigregister(Aonia)

class Eonia(OvernightIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Eonia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Eonia
    __del__ = lambda self: None
Eonia_swigregister = _QuantLib.Eonia_swigregister
Eonia_swigregister(Eonia)

class Sonia(OvernightIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Sonia(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Sonia
    __del__ = lambda self: None
Sonia_swigregister = _QuantLib.Sonia_swigregister
Sonia_swigregister(Sonia)

class FedFunds(OvernightIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FedFunds(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FedFunds
    __del__ = lambda self: None
FedFunds_swigregister = _QuantLib.FedFunds_swigregister
FedFunds_swigregister(FedFunds)

class Nzocr(OvernightIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Nzocr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Nzocr
    __del__ = lambda self: None
Nzocr_swigregister = _QuantLib.Nzocr_swigregister
Nzocr_swigregister(Nzocr)

class EuriborSwapIsdaFixA(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EuriborSwapIsdaFixA(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixA
    __del__ = lambda self: None
EuriborSwapIsdaFixA_swigregister = _QuantLib.EuriborSwapIsdaFixA_swigregister
EuriborSwapIsdaFixA_swigregister(EuriborSwapIsdaFixA)

class EuriborSwapIsdaFixB(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EuriborSwapIsdaFixB(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIsdaFixB
    __del__ = lambda self: None
EuriborSwapIsdaFixB_swigregister = _QuantLib.EuriborSwapIsdaFixB_swigregister
EuriborSwapIsdaFixB_swigregister(EuriborSwapIsdaFixB)

class EuriborSwapIfrFix(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EuriborSwapIfrFix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EuriborSwapIfrFix
    __del__ = lambda self: None
EuriborSwapIfrFix_swigregister = _QuantLib.EuriborSwapIfrFix_swigregister
EuriborSwapIfrFix_swigregister(EuriborSwapIfrFix)

class EurLiborSwapIsdaFixA(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EurLiborSwapIsdaFixA(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixA
    __del__ = lambda self: None
EurLiborSwapIsdaFixA_swigregister = _QuantLib.EurLiborSwapIsdaFixA_swigregister
EurLiborSwapIsdaFixA_swigregister(EurLiborSwapIsdaFixA)

class EurLiborSwapIsdaFixB(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EurLiborSwapIsdaFixB(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIsdaFixB
    __del__ = lambda self: None
EurLiborSwapIsdaFixB_swigregister = _QuantLib.EurLiborSwapIsdaFixB_swigregister
EurLiborSwapIsdaFixB_swigregister(EurLiborSwapIsdaFixB)

class EurLiborSwapIfrFix(SwapIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EurLiborSwapIfrFix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EurLiborSwapIfrFix
    __del__ = lambda self: None
EurLiborSwapIfrFix_swigregister = _QuantLib.EurLiborSwapIfrFix_swigregister
EurLiborSwapIfrFix_swigregister(EurLiborSwapIfrFix)

class Brent(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_Brent()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Brent
    __del__ = lambda self: None
Brent_swigregister = _QuantLib.Brent_swigregister
Brent_swigregister(Brent)

class Bisection(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_Bisection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Bisection
    __del__ = lambda self: None
Bisection_swigregister = _QuantLib.Bisection_swigregister
Bisection_swigregister(Bisection)

class FalsePosition(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_FalsePosition()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FalsePosition
    __del__ = lambda self: None
FalsePosition_swigregister = _QuantLib.FalsePosition_swigregister
FalsePosition_swigregister(FalsePosition)

class Ridder(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_Ridder()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Ridder
    __del__ = lambda self: None
Ridder_swigregister = _QuantLib.Ridder_swigregister
Ridder_swigregister(Ridder)

class Secant(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_Secant()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Secant
    __del__ = lambda self: None
Secant_swigregister = _QuantLib.Secant_swigregister
Secant_swigregister(Secant)

class Newton(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_Newton()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Newton
    __del__ = lambda self: None
Newton_swigregister = _QuantLib.Newton_swigregister
Newton_swigregister(Newton)

class NewtonSafe(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def setMaxEvaluations(self, 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):
        this = _QuantLib.new_NewtonSafe()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NewtonSafe
    __del__ = lambda self: None
NewtonSafe_swigregister = _QuantLib.NewtonSafe_swigregister
NewtonSafe_swigregister(NewtonSafe)

class Constraint(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_Constraint
    __del__ = lambda self: None
Constraint_swigregister = _QuantLib.Constraint_swigregister
Constraint_swigregister(Constraint)

class BoundaryConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, lower, upper):
        this = _QuantLib.new_BoundaryConstraint(lower, upper)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BoundaryConstraint
    __del__ = lambda self: None
BoundaryConstraint_swigregister = _QuantLib.BoundaryConstraint_swigregister
BoundaryConstraint_swigregister(BoundaryConstraint)

class NoConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_NoConstraint()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NoConstraint
    __del__ = lambda self: None
NoConstraint_swigregister = _QuantLib.NoConstraint_swigregister
NoConstraint_swigregister(NoConstraint)

class PositiveConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_PositiveConstraint()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PositiveConstraint
    __del__ = lambda self: None
PositiveConstraint_swigregister = _QuantLib.PositiveConstraint_swigregister
PositiveConstraint_swigregister(PositiveConstraint)

class CompositeConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, c1, c2):
        this = _QuantLib.new_CompositeConstraint(c1, c2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CompositeConstraint
    __del__ = lambda self: None
CompositeConstraint_swigregister = _QuantLib.CompositeConstraint_swigregister
CompositeConstraint_swigregister(CompositeConstraint)

class NonhomogeneousBoundaryConstraint(Constraint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, l, u):
        this = _QuantLib.new_NonhomogeneousBoundaryConstraint(l, u)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NonhomogeneousBoundaryConstraint
    __del__ = lambda self: None
NonhomogeneousBoundaryConstraint_swigregister = _QuantLib.NonhomogeneousBoundaryConstraint_swigregister
NonhomogeneousBoundaryConstraint_swigregister(NonhomogeneousBoundaryConstraint)

class EndCriteria(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NoCriteria = _QuantLib.EndCriteria_NoCriteria
    MaxIterations = _QuantLib.EndCriteria_MaxIterations
    StationaryPoint = _QuantLib.EndCriteria_StationaryPoint
    StationaryFunctionValue = _QuantLib.EndCriteria_StationaryFunctionValue
    StationaryFunctionAccuracy = _QuantLib.EndCriteria_StationaryFunctionAccuracy
    ZeroGradientNorm = _QuantLib.EndCriteria_ZeroGradientNorm
    Unknown = _QuantLib.EndCriteria_Unknown

    def __init__(self, maxIteration, maxStationaryStateIterations, rootEpsilon, functionEpsilon, gradientNormEpsilon):
        this = _QuantLib.new_EndCriteria(maxIteration, maxStationaryStateIterations, rootEpsilon, functionEpsilon, gradientNormEpsilon)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
EndCriteria_swigregister = _QuantLib.EndCriteria_swigregister
EndCriteria_swigregister(EndCriteria)

class OptimizationMethod(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_OptimizationMethod
    __del__ = lambda self: None
OptimizationMethod_swigregister = _QuantLib.OptimizationMethod_swigregister
OptimizationMethod_swigregister(OptimizationMethod)

class ConjugateGradient(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ConjugateGradient()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConjugateGradient
    __del__ = lambda self: None
ConjugateGradient_swigregister = _QuantLib.ConjugateGradient_swigregister
ConjugateGradient_swigregister(ConjugateGradient)

class Simplex(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, arg2):
        this = _QuantLib.new_Simplex(arg2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Simplex
    __del__ = lambda self: None
Simplex_swigregister = _QuantLib.Simplex_swigregister
Simplex_swigregister(Simplex)

class SteepestDescent(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_SteepestDescent()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SteepestDescent
    __del__ = lambda self: None
SteepestDescent_swigregister = _QuantLib.SteepestDescent_swigregister
SteepestDescent_swigregister(SteepestDescent)

class BFGS(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BFGS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BFGS
    __del__ = lambda self: None
BFGS_swigregister = _QuantLib.BFGS_swigregister
BFGS_swigregister(BFGS)

class LevenbergMarquardt(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, epsfcn=1.0e-8, xtol=1.0e-8, gtol=1.0e-8):
        this = _QuantLib.new_LevenbergMarquardt(epsfcn, xtol, gtol)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LevenbergMarquardt
    __del__ = lambda self: None
LevenbergMarquardt_swigregister = _QuantLib.LevenbergMarquardt_swigregister
LevenbergMarquardt_swigregister(LevenbergMarquardt)

class DifferentialEvolution(OptimizationMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_DifferentialEvolution()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DifferentialEvolution
    __del__ = lambda self: None
DifferentialEvolution_swigregister = _QuantLib.DifferentialEvolution_swigregister
DifferentialEvolution_swigregister(DifferentialEvolution)

class SamplerGaussian(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_SamplerGaussian(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SamplerGaussian
    __del__ = lambda self: None
SamplerGaussian_swigregister = _QuantLib.SamplerGaussian_swigregister
SamplerGaussian_swigregister(SamplerGaussian)

class SamplerLogNormal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_SamplerLogNormal(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SamplerLogNormal
    __del__ = lambda self: None
SamplerLogNormal_swigregister = _QuantLib.SamplerLogNormal_swigregister
SamplerLogNormal_swigregister(SamplerLogNormal)

class SamplerMirrorGaussian(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, lower, upper, seed=0):
        this = _QuantLib.new_SamplerMirrorGaussian(lower, upper, seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SamplerMirrorGaussian
    __del__ = lambda self: None
SamplerMirrorGaussian_swigregister = _QuantLib.SamplerMirrorGaussian_swigregister
SamplerMirrorGaussian_swigregister(SamplerMirrorGaussian)

class ProbabilityBoltzmannDownhill(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_ProbabilityBoltzmannDownhill(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ProbabilityBoltzmannDownhill
    __del__ = lambda self: None
ProbabilityBoltzmannDownhill_swigregister = _QuantLib.ProbabilityBoltzmannDownhill_swigregister
ProbabilityBoltzmannDownhill_swigregister(ProbabilityBoltzmannDownhill)

class TemperatureExponential(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, initialTemp, dimension, power=0.95):
        this = _QuantLib.new_TemperatureExponential(initialTemp, dimension, power)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TemperatureExponential
    __del__ = lambda self: None
TemperatureExponential_swigregister = _QuantLib.TemperatureExponential_swigregister
TemperatureExponential_swigregister(TemperatureExponential)

class ReannealingTrivial(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ReannealingTrivial()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ReannealingTrivial
    __del__ = lambda self: None
ReannealingTrivial_swigregister = _QuantLib.ReannealingTrivial_swigregister
ReannealingTrivial_swigregister(ReannealingTrivial)

class GaussianSimulatedAnnealing(OptimizationMethod):
    thisown = _swig_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):
        this = _QuantLib.new_GaussianSimulatedAnnealing(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GaussianSimulatedAnnealing
    __del__ = lambda self: None
GaussianSimulatedAnnealing_swigregister = _QuantLib.GaussianSimulatedAnnealing_swigregister
GaussianSimulatedAnnealing_swigregister(GaussianSimulatedAnnealing)

class MirrorGaussianSimulatedAnnealing(OptimizationMethod):
    thisown = _swig_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):
        this = _QuantLib.new_MirrorGaussianSimulatedAnnealing(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MirrorGaussianSimulatedAnnealing
    __del__ = lambda self: None
MirrorGaussianSimulatedAnnealing_swigregister = _QuantLib.MirrorGaussianSimulatedAnnealing_swigregister
MirrorGaussianSimulatedAnnealing_swigregister(MirrorGaussianSimulatedAnnealing)

class LogNormalSimulatedAnnealing(OptimizationMethod):
    thisown = _swig_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):
        this = _QuantLib.new_LogNormalSimulatedAnnealing(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LogNormalSimulatedAnnealing
    __del__ = lambda self: None
LogNormalSimulatedAnnealing_swigregister = _QuantLib.LogNormalSimulatedAnnealing_swigregister
LogNormalSimulatedAnnealing_swigregister(LogNormalSimulatedAnnealing)

class Optimizer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def solve(self, function, c, m, e, iv):
        return _QuantLib.Optimizer_solve(self, function, c, m, e, iv)

    def __init__(self):
        this = _QuantLib.new_Optimizer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Optimizer
    __del__ = lambda self: None
Optimizer_swigregister = _QuantLib.Optimizer_swigregister
Optimizer_swigregister(Optimizer)

ShiftedLognormal = _QuantLib.ShiftedLognormal
Normal = _QuantLib.Normal
class BlackVolTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.BlackVolTermStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_BlackVolTermStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackVolTermStructure
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.BlackVolTermStructure_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.BlackVolTermStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.BlackVolTermStructure_calendar(self)

    def maxDate(self):
        return _QuantLib.BlackVolTermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.BlackVolTermStructure_maxTime(self)

    def minStrike(self):
        return _QuantLib.BlackVolTermStructure_minStrike(self)

    def maxStrike(self):
        return _QuantLib.BlackVolTermStructure_maxStrike(self)

    def blackVol(self, *args):
        return _QuantLib.BlackVolTermStructure_blackVol(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.BlackVolTermStructure_blackVariance(self, *args)

    def blackForwardVol(self, *args):
        return _QuantLib.BlackVolTermStructure_blackForwardVol(self, *args)

    def blackForwardVariance(self, *args):
        return _QuantLib.BlackVolTermStructure_blackForwardVariance(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.BlackVolTermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.BlackVolTermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.BlackVolTermStructure_allowsExtrapolation(self)
BlackVolTermStructure_swigregister = _QuantLib.BlackVolTermStructure_swigregister
BlackVolTermStructure_swigregister(BlackVolTermStructure)

class BlackVolTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BlackVolTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.BlackVolTermStructureHandle___deref__(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
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.BlackVolTermStructureHandle_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.BlackVolTermStructureHandle_dayCounter(self)

    def calendar(self):
        return _QuantLib.BlackVolTermStructureHandle_calendar(self)

    def maxDate(self):
        return _QuantLib.BlackVolTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.BlackVolTermStructureHandle_maxTime(self)

    def minStrike(self):
        return _QuantLib.BlackVolTermStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.BlackVolTermStructureHandle_maxStrike(self)

    def blackVol(self, *args):
        return _QuantLib.BlackVolTermStructureHandle_blackVol(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.BlackVolTermStructureHandle_blackVariance(self, *args)

    def blackForwardVol(self, *args):
        return _QuantLib.BlackVolTermStructureHandle_blackForwardVol(self, *args)

    def blackForwardVariance(self, *args):
        return _QuantLib.BlackVolTermStructureHandle_blackForwardVariance(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.BlackVolTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.BlackVolTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.BlackVolTermStructureHandle_allowsExtrapolation(self)
BlackVolTermStructureHandle_swigregister = _QuantLib.BlackVolTermStructureHandle_swigregister
BlackVolTermStructureHandle_swigregister(BlackVolTermStructureHandle)

class RelinkableBlackVolTermStructureHandle(BlackVolTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableBlackVolTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableBlackVolTermStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableBlackVolTermStructureHandle
    __del__ = lambda self: None
RelinkableBlackVolTermStructureHandle_swigregister = _QuantLib.RelinkableBlackVolTermStructureHandle_swigregister
RelinkableBlackVolTermStructureHandle_swigregister(RelinkableBlackVolTermStructureHandle)

class LocalVolTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.LocalVolTermStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_LocalVolTermStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LocalVolTermStructure
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.LocalVolTermStructure_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.LocalVolTermStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.LocalVolTermStructure_calendar(self)

    def maxDate(self):
        return _QuantLib.LocalVolTermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.LocalVolTermStructure_maxTime(self)

    def minStrike(self):
        return _QuantLib.LocalVolTermStructure_minStrike(self)

    def maxStrike(self):
        return _QuantLib.LocalVolTermStructure_maxStrike(self)

    def localVol(self, *args):
        return _QuantLib.LocalVolTermStructure_localVol(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.LocalVolTermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.LocalVolTermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.LocalVolTermStructure_allowsExtrapolation(self)
LocalVolTermStructure_swigregister = _QuantLib.LocalVolTermStructure_swigregister
LocalVolTermStructure_swigregister(LocalVolTermStructure)

class LocalVolTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_LocalVolTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.LocalVolTermStructureHandle___deref__(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
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.LocalVolTermStructureHandle_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.LocalVolTermStructureHandle_dayCounter(self)

    def calendar(self):
        return _QuantLib.LocalVolTermStructureHandle_calendar(self)

    def maxDate(self):
        return _QuantLib.LocalVolTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.LocalVolTermStructureHandle_maxTime(self)

    def minStrike(self):
        return _QuantLib.LocalVolTermStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.LocalVolTermStructureHandle_maxStrike(self)

    def localVol(self, *args):
        return _QuantLib.LocalVolTermStructureHandle_localVol(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.LocalVolTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.LocalVolTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.LocalVolTermStructureHandle_allowsExtrapolation(self)
LocalVolTermStructureHandle_swigregister = _QuantLib.LocalVolTermStructureHandle_swigregister
LocalVolTermStructureHandle_swigregister(LocalVolTermStructureHandle)

class RelinkableLocalVolTermStructureHandle(LocalVolTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableLocalVolTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableLocalVolTermStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableLocalVolTermStructureHandle
    __del__ = lambda self: None
RelinkableLocalVolTermStructureHandle_swigregister = _QuantLib.RelinkableLocalVolTermStructureHandle_swigregister
RelinkableLocalVolTermStructureHandle_swigregister(RelinkableLocalVolTermStructureHandle)

class OptionletVolatilityStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.OptionletVolatilityStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_OptionletVolatilityStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_OptionletVolatilityStructure
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.OptionletVolatilityStructure_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.OptionletVolatilityStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.OptionletVolatilityStructure_calendar(self)

    def maxDate(self):
        return _QuantLib.OptionletVolatilityStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.OptionletVolatilityStructure_maxTime(self)

    def minStrike(self):
        return _QuantLib.OptionletVolatilityStructure_minStrike(self)

    def maxStrike(self):
        return _QuantLib.OptionletVolatilityStructure_maxStrike(self)

    def volatility(self, *args):
        return _QuantLib.OptionletVolatilityStructure_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.OptionletVolatilityStructure_blackVariance(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructure_allowsExtrapolation(self)
OptionletVolatilityStructure_swigregister = _QuantLib.OptionletVolatilityStructure_swigregister
OptionletVolatilityStructure_swigregister(OptionletVolatilityStructure)

class OptionletVolatilityStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_OptionletVolatilityStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.OptionletVolatilityStructureHandle___deref__(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
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.OptionletVolatilityStructureHandle_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.OptionletVolatilityStructureHandle_dayCounter(self)

    def calendar(self):
        return _QuantLib.OptionletVolatilityStructureHandle_calendar(self)

    def maxDate(self):
        return _QuantLib.OptionletVolatilityStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.OptionletVolatilityStructureHandle_maxTime(self)

    def minStrike(self):
        return _QuantLib.OptionletVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.OptionletVolatilityStructureHandle_maxStrike(self)

    def volatility(self, *args):
        return _QuantLib.OptionletVolatilityStructureHandle_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.OptionletVolatilityStructureHandle_blackVariance(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.OptionletVolatilityStructureHandle_allowsExtrapolation(self)
OptionletVolatilityStructureHandle_swigregister = _QuantLib.OptionletVolatilityStructureHandle_swigregister
OptionletVolatilityStructureHandle_swigregister(OptionletVolatilityStructureHandle)

class RelinkableOptionletVolatilityStructureHandle(OptionletVolatilityStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableOptionletVolatilityStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableOptionletVolatilityStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableOptionletVolatilityStructureHandle
    __del__ = lambda self: None
RelinkableOptionletVolatilityStructureHandle_swigregister = _QuantLib.RelinkableOptionletVolatilityStructureHandle_swigregister
RelinkableOptionletVolatilityStructureHandle_swigregister(RelinkableOptionletVolatilityStructureHandle)

class SwaptionVolatilityStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.SwaptionVolatilityStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_SwaptionVolatilityStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityStructure
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.SwaptionVolatilityStructure_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.SwaptionVolatilityStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.SwaptionVolatilityStructure_calendar(self)

    def maxSwapTenor(self):
        return _QuantLib.SwaptionVolatilityStructure_maxSwapTenor(self)

    def maxSwapLength(self):
        return _QuantLib.SwaptionVolatilityStructure_maxSwapLength(self)

    def minStrike(self):
        return _QuantLib.SwaptionVolatilityStructure_minStrike(self)

    def maxStrike(self):
        return _QuantLib.SwaptionVolatilityStructure_maxStrike(self)

    def volatility(self, *args):
        return _QuantLib.SwaptionVolatilityStructure_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.SwaptionVolatilityStructure_blackVariance(self, *args)

    def optionDateFromTenor(self, p):
        return _QuantLib.SwaptionVolatilityStructure_optionDateFromTenor(self, p)

    def enableExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructure_allowsExtrapolation(self)
SwaptionVolatilityStructure_swigregister = _QuantLib.SwaptionVolatilityStructure_swigregister
SwaptionVolatilityStructure_swigregister(SwaptionVolatilityStructure)

class SwaptionVolatilityStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SwaptionVolatilityStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.SwaptionVolatilityStructureHandle___deref__(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
    __del__ = lambda self: None

    def referenceDate(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_referenceDate(self)

    def dayCounter(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_dayCounter(self)

    def calendar(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_calendar(self)

    def maxSwapTenor(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_maxSwapTenor(self)

    def maxSwapLength(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_maxSwapLength(self)

    def minStrike(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_minStrike(self)

    def maxStrike(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_maxStrike(self)

    def volatility(self, *args):
        return _QuantLib.SwaptionVolatilityStructureHandle_volatility(self, *args)

    def blackVariance(self, *args):
        return _QuantLib.SwaptionVolatilityStructureHandle_blackVariance(self, *args)

    def optionDateFromTenor(self, p):
        return _QuantLib.SwaptionVolatilityStructureHandle_optionDateFromTenor(self, p)

    def enableExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.SwaptionVolatilityStructureHandle_allowsExtrapolation(self)
SwaptionVolatilityStructureHandle_swigregister = _QuantLib.SwaptionVolatilityStructureHandle_swigregister
SwaptionVolatilityStructureHandle_swigregister(SwaptionVolatilityStructureHandle)

class RelinkableSwaptionVolatilityStructureHandle(SwaptionVolatilityStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableSwaptionVolatilityStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableSwaptionVolatilityStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableSwaptionVolatilityStructureHandle
    __del__ = lambda self: None
RelinkableSwaptionVolatilityStructureHandle_swigregister = _QuantLib.RelinkableSwaptionVolatilityStructureHandle_swigregister
RelinkableSwaptionVolatilityStructureHandle_swigregister(RelinkableSwaptionVolatilityStructureHandle)

class BlackConstantVol(BlackVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BlackConstantVol(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackConstantVol
    __del__ = lambda self: None
BlackConstantVol_swigregister = _QuantLib.BlackConstantVol_swigregister
BlackConstantVol_swigregister(BlackConstantVol)

class BlackVarianceCurve(BlackVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, referenceDate, dates, volatilities, dayCounter, forceMonotoneVariance=True):
        this = _QuantLib.new_BlackVarianceCurve(referenceDate, dates, volatilities, dayCounter, forceMonotoneVariance)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackVarianceCurve
    __del__ = lambda self: None
BlackVarianceCurve_swigregister = _QuantLib.BlackVarianceCurve_swigregister
BlackVarianceCurve_swigregister(BlackVarianceCurve)

class BlackVarianceSurface(BlackVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_BlackVarianceSurface(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setInterpolation(self, *args):
        return _QuantLib.BlackVarianceSurface_setInterpolation(self, *args)
    ConstantExtrapolation = _QuantLib.BlackVarianceSurface_ConstantExtrapolation
    InterpolatorDefaultExtrapolation = _QuantLib.BlackVarianceSurface_InterpolatorDefaultExtrapolation
    __swig_destroy__ = _QuantLib.delete_BlackVarianceSurface
    __del__ = lambda self: None
BlackVarianceSurface_swigregister = _QuantLib.BlackVarianceSurface_swigregister
BlackVarianceSurface_swigregister(BlackVarianceSurface)

class LocalConstantVol(LocalVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_LocalConstantVol(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LocalConstantVol
    __del__ = lambda self: None
LocalConstantVol_swigregister = _QuantLib.LocalConstantVol_swigregister
LocalConstantVol_swigregister(LocalConstantVol)

class LocalVolSurface(LocalVolTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_LocalVolSurface(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LocalVolSurface
    __del__ = lambda self: None
LocalVolSurface_swigregister = _QuantLib.LocalVolSurface_swigregister
LocalVolSurface_swigregister(LocalVolSurface)

class ConstantOptionletVolatility(OptionletVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ConstantOptionletVolatility(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConstantOptionletVolatility
    __del__ = lambda self: None
ConstantOptionletVolatility_swigregister = _QuantLib.ConstantOptionletVolatility_swigregister
ConstantOptionletVolatility_swigregister(ConstantOptionletVolatility)

class ConstantSwaptionVolatility(SwaptionVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ConstantSwaptionVolatility(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConstantSwaptionVolatility
    __del__ = lambda self: None
ConstantSwaptionVolatility_swigregister = _QuantLib.ConstantSwaptionVolatility_swigregister
ConstantSwaptionVolatility_swigregister(ConstantSwaptionVolatility)

class SwaptionVolatilityMatrix(SwaptionVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SwaptionVolatilityMatrix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SwaptionVolatilityMatrix
    __del__ = lambda self: None
SwaptionVolatilityMatrix_swigregister = _QuantLib.SwaptionVolatilityMatrix_swigregister
SwaptionVolatilityMatrix_swigregister(SwaptionVolatilityMatrix)

class SwaptionVolCube1(SwaptionVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SwaptionVolCube1(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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)
    __swig_destroy__ = _QuantLib.delete_SwaptionVolCube1
    __del__ = lambda self: None
SwaptionVolCube1_swigregister = _QuantLib.SwaptionVolCube1_swigregister
SwaptionVolCube1_swigregister(SwaptionVolCube1)

class SwaptionVolCube2(SwaptionVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndexBase, shortSwapIndexBase, vegaWeightedSmileFit):
        this = _QuantLib.new_SwaptionVolCube2(atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndexBase, shortSwapIndexBase, vegaWeightedSmileFit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SwaptionVolCube2
    __del__ = lambda self: None
SwaptionVolCube2_swigregister = _QuantLib.SwaptionVolCube2_swigregister
SwaptionVolCube2_swigregister(SwaptionVolCube2)

class StochasticProcess(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.StochasticProcess_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_StochasticProcess()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_StochasticProcess
    __del__ = lambda self: None

    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)
StochasticProcess_swigregister = _QuantLib.StochasticProcess_swigregister
StochasticProcess_swigregister(StochasticProcess)

class StochasticProcessVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.StochasticProcessVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_StochasticProcessVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
StochasticProcessVector_swigregister = _QuantLib.StochasticProcessVector_swigregister
StochasticProcessVector_swigregister(StochasticProcessVector)

class StochasticProcess1D(StochasticProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    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
    __del__ = lambda self: None
StochasticProcess1D_swigregister = _QuantLib.StochasticProcess1D_swigregister
StochasticProcess1D_swigregister(StochasticProcess1D)

class GeneralizedBlackScholesProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s0, dividendTS, riskFreeTS, volTS):
        this = _QuantLib.new_GeneralizedBlackScholesProcess(s0, dividendTS, riskFreeTS, volTS)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def stateVariable(self):
        return _QuantLib.GeneralizedBlackScholesProcess_stateVariable(self)

    def dividendYield(self):
        return _QuantLib.GeneralizedBlackScholesProcess_dividendYield(self)

    def riskFreeRate(self):
        return _QuantLib.GeneralizedBlackScholesProcess_riskFreeRate(self)

    def blackVolatility(self):
        return _QuantLib.GeneralizedBlackScholesProcess_blackVolatility(self)
    __swig_destroy__ = _QuantLib.delete_GeneralizedBlackScholesProcess
    __del__ = lambda self: None
GeneralizedBlackScholesProcess_swigregister = _QuantLib.GeneralizedBlackScholesProcess_swigregister
GeneralizedBlackScholesProcess_swigregister(GeneralizedBlackScholesProcess)

class BlackScholesProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s0, riskFreeTS, volTS):
        this = _QuantLib.new_BlackScholesProcess(s0, riskFreeTS, volTS)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackScholesProcess
    __del__ = lambda self: None
BlackScholesProcess_swigregister = _QuantLib.BlackScholesProcess_swigregister
BlackScholesProcess_swigregister(BlackScholesProcess)

class BlackScholesMertonProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s0, dividendTS, riskFreeTS, volTS):
        this = _QuantLib.new_BlackScholesMertonProcess(s0, dividendTS, riskFreeTS, volTS)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackScholesMertonProcess
    __del__ = lambda self: None
BlackScholesMertonProcess_swigregister = _QuantLib.BlackScholesMertonProcess_swigregister
BlackScholesMertonProcess_swigregister(BlackScholesMertonProcess)

class BlackProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s0, riskFreeTS, volTS):
        this = _QuantLib.new_BlackProcess(s0, riskFreeTS, volTS)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackProcess
    __del__ = lambda self: None
BlackProcess_swigregister = _QuantLib.BlackProcess_swigregister
BlackProcess_swigregister(BlackProcess)

class GarmanKohlagenProcess(GeneralizedBlackScholesProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s0, foreignRiskFreeTS, domesticRiskFreeTS, volTS):
        this = _QuantLib.new_GarmanKohlagenProcess(s0, foreignRiskFreeTS, domesticRiskFreeTS, volTS)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GarmanKohlagenProcess
    __del__ = lambda self: None
GarmanKohlagenProcess_swigregister = _QuantLib.GarmanKohlagenProcess_swigregister
GarmanKohlagenProcess_swigregister(GarmanKohlagenProcess)

class Merton76Process(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, stateVariable, dividendTS, riskFreeTS, volTS, jumpIntensity, meanLogJump, jumpVolatility):
        this = _QuantLib.new_Merton76Process(stateVariable, dividendTS, riskFreeTS, volTS, jumpIntensity, meanLogJump, jumpVolatility)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Merton76Process
    __del__ = lambda self: None
Merton76Process_swigregister = _QuantLib.Merton76Process_swigregister
Merton76Process_swigregister(Merton76Process)

class StochasticProcessArray(StochasticProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, array, correlation):
        this = _QuantLib.new_StochasticProcessArray(array, correlation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_StochasticProcessArray
    __del__ = lambda self: None
StochasticProcessArray_swigregister = _QuantLib.StochasticProcessArray_swigregister
StochasticProcessArray_swigregister(StochasticProcessArray)

class GeometricBrownianMotionProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, initialValue, mu, sigma):
        this = _QuantLib.new_GeometricBrownianMotionProcess(initialValue, mu, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GeometricBrownianMotionProcess
    __del__ = lambda self: None
GeometricBrownianMotionProcess_swigregister = _QuantLib.GeometricBrownianMotionProcess_swigregister
GeometricBrownianMotionProcess_swigregister(GeometricBrownianMotionProcess)

class VarianceGammaProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s0, dividendYield, riskFreeRate, sigma, nu, theta):
        this = _QuantLib.new_VarianceGammaProcess(s0, dividendYield, riskFreeRate, sigma, nu, theta)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_VarianceGammaProcess
    __del__ = lambda self: None
VarianceGammaProcess_swigregister = _QuantLib.VarianceGammaProcess_swigregister
VarianceGammaProcess_swigregister(VarianceGammaProcess)

class HestonProcess(StochasticProcess):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, riskFreeTS, dividendTS, s0, v0, kappa, theta, sigma, rho):
        this = _QuantLib.new_HestonProcess(riskFreeTS, dividendTS, s0, v0, kappa, theta, sigma, rho)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
HestonProcess_swigregister = _QuantLib.HestonProcess_swigregister
HestonProcess_swigregister(HestonProcess)

class BatesProcess(HestonProcess):
    thisown = _swig_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, arg10, nu, delta):
        this = _QuantLib.new_BatesProcess(riskFreeRate, dividendYield, s0, v0, kappa, theta, sigma, rho, arg10, nu, delta)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BatesProcess
    __del__ = lambda self: None
BatesProcess_swigregister = _QuantLib.BatesProcess_swigregister
BatesProcess_swigregister(BatesProcess)

class HullWhiteProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, riskFreeTS, a, sigma):
        this = _QuantLib.new_HullWhiteProcess(riskFreeTS, a, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HullWhiteProcess
    __del__ = lambda self: None
HullWhiteProcess_swigregister = _QuantLib.HullWhiteProcess_swigregister
HullWhiteProcess_swigregister(HullWhiteProcess)

class HullWhiteForwardProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, riskFreeTS, a, sigma):
        this = _QuantLib.new_HullWhiteForwardProcess(riskFreeTS, a, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
HullWhiteForwardProcess_swigregister = _QuantLib.HullWhiteForwardProcess_swigregister
HullWhiteForwardProcess_swigregister(HullWhiteForwardProcess)

class GsrProcess(StochasticProcess1D):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, times, vols, reversions, T=60.0):
        this = _QuantLib.new_GsrProcess(times, vols, reversions, T)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
GsrProcess_swigregister = _QuantLib.GsrProcess_swigregister
GsrProcess_swigregister(GsrProcess)


def as_gsr_process(proc):
    return _QuantLib.as_gsr_process(proc)
as_gsr_process = _QuantLib.as_gsr_process
class PricingEngine(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_PricingEngine()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PricingEngine
    __del__ = lambda self: None
PricingEngine_swigregister = _QuantLib.PricingEngine_swigregister
PricingEngine_swigregister(PricingEngine)

class Instrument(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.Instrument_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_Instrument()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Instrument
    __del__ = lambda self: None

    def NPV(self):
        return _QuantLib.Instrument_NPV(self)

    def errorEstimate(self):
        return _QuantLib.Instrument_errorEstimate(self)

    def isExpired(self):
        return _QuantLib.Instrument_isExpired(self)

    def setPricingEngine(self, 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)
Instrument_swigregister = _QuantLib.Instrument_swigregister
Instrument_swigregister(Instrument)

class InstrumentVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_InstrumentVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
InstrumentVector_swigregister = _QuantLib.InstrumentVector_swigregister
InstrumentVector_swigregister(InstrumentVector)

class Stock(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, quote):
        this = _QuantLib.new_Stock(quote)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Stock
    __del__ = lambda self: None
Stock_swigregister = _QuantLib.Stock_swigregister
Stock_swigregister(Stock)

class CompositeInstrument(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_CompositeInstrument()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CompositeInstrument_swigregister = _QuantLib.CompositeInstrument_swigregister
CompositeInstrument_swigregister(CompositeInstrument)

class DateGeneration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Backward = _QuantLib.DateGeneration_Backward
    Forward = _QuantLib.DateGeneration_Forward
    Zero = _QuantLib.DateGeneration_Zero
    ThirdWednesday = _QuantLib.DateGeneration_ThirdWednesday
    Twentieth = _QuantLib.DateGeneration_Twentieth
    TwentiethIMM = _QuantLib.DateGeneration_TwentiethIMM
    OldCDS = _QuantLib.DateGeneration_OldCDS
    CDS = _QuantLib.DateGeneration_CDS
    CDS2015 = _QuantLib.DateGeneration_CDS2015

    def __init__(self):
        this = _QuantLib.new_DateGeneration()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DateGeneration
    __del__ = lambda self: None
DateGeneration_swigregister = _QuantLib.DateGeneration_swigregister
DateGeneration_swigregister(DateGeneration)

class Schedule(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Schedule(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def isRegular(self, i):
        return _QuantLib.Schedule_isRegular(self, i)

    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
    __del__ = lambda self: None
Schedule_swigregister = _QuantLib.Schedule_swigregister
Schedule_swigregister(Schedule)

class CashFlow(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.CashFlow_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_CashFlow()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CashFlow
    __del__ = lambda self: None

    def amount(self):
        return _QuantLib.CashFlow_amount(self)

    def date(self):
        return _QuantLib.CashFlow_date(self)
CashFlow_swigregister = _QuantLib.CashFlow_swigregister
CashFlow_swigregister(CashFlow)

class Leg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.Leg_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_Leg(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Leg_swigregister = _QuantLib.Leg_swigregister
Leg_swigregister(Leg)

class SimpleCashFlow(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        this = _QuantLib.new_SimpleCashFlow(amount, date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SimpleCashFlow
    __del__ = lambda self: None
SimpleCashFlow_swigregister = _QuantLib.SimpleCashFlow_swigregister
SimpleCashFlow_swigregister(SimpleCashFlow)

class Redemption(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        this = _QuantLib.new_Redemption(amount, date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Redemption
    __del__ = lambda self: None
Redemption_swigregister = _QuantLib.Redemption_swigregister
Redemption_swigregister(Redemption)

class AmortizingPayment(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        this = _QuantLib.new_AmortizingPayment(amount, date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AmortizingPayment
    __del__ = lambda self: None
AmortizingPayment_swigregister = _QuantLib.AmortizingPayment_swigregister
AmortizingPayment_swigregister(AmortizingPayment)

class Coupon(CashFlow):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def 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
    __del__ = lambda self: None
Coupon_swigregister = _QuantLib.Coupon_swigregister
Coupon_swigregister(Coupon)


def as_coupon(cf):
    return _QuantLib.as_coupon(cf)
as_coupon = _QuantLib.as_coupon
class FixedRateCoupon(Coupon):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_FixedRateCoupon(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def interestRate(self):
        return _QuantLib.FixedRateCoupon_interestRate(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateCoupon
    __del__ = lambda self: None
FixedRateCoupon_swigregister = _QuantLib.FixedRateCoupon_swigregister
FixedRateCoupon_swigregister(FixedRateCoupon)


def as_fixed_rate_coupon(cf):
    return _QuantLib.as_fixed_rate_coupon(cf)
as_fixed_rate_coupon = _QuantLib.as_fixed_rate_coupon
class FloatingRateCouponPricer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_FloatingRateCouponPricer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FloatingRateCouponPricer
    __del__ = lambda self: None
FloatingRateCouponPricer_swigregister = _QuantLib.FloatingRateCouponPricer_swigregister
FloatingRateCouponPricer_swigregister(FloatingRateCouponPricer)


def setCouponPricer(arg1, arg2):
    return _QuantLib.setCouponPricer(arg1, arg2)
setCouponPricer = _QuantLib.setCouponPricer
class FloatingRateCoupon(Coupon):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def 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
    __del__ = lambda self: None
FloatingRateCoupon_swigregister = _QuantLib.FloatingRateCoupon_swigregister
FloatingRateCoupon_swigregister(FloatingRateCoupon)


def as_floating_rate_coupon(cf):
    return _QuantLib.as_floating_rate_coupon(cf)
as_floating_rate_coupon = _QuantLib.as_floating_rate_coupon
class CappedFlooredCoupon(FloatingRateCoupon):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_CappedFlooredCoupon(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CappedFlooredCoupon_swigregister = _QuantLib.CappedFlooredCoupon_swigregister
CappedFlooredCoupon_swigregister(CappedFlooredCoupon)

class IborCoupon(FloatingRateCoupon):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_IborCoupon(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IborCoupon
    __del__ = lambda self: None
IborCoupon_swigregister = _QuantLib.IborCoupon_swigregister
IborCoupon_swigregister(IborCoupon)

class IborCouponPricer(FloatingRateCouponPricer):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def capletVolatility(self):
        return _QuantLib.IborCouponPricer_capletVolatility(self)

    def setCapletVolatility(self, *args):
        return _QuantLib.IborCouponPricer_setCapletVolatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_IborCouponPricer
    __del__ = lambda self: None
IborCouponPricer_swigregister = _QuantLib.IborCouponPricer_swigregister
IborCouponPricer_swigregister(IborCouponPricer)

class BlackIborCouponPricer(IborCouponPricer):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BlackIborCouponPricer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackIborCouponPricer
    __del__ = lambda self: None
BlackIborCouponPricer_swigregister = _QuantLib.BlackIborCouponPricer_swigregister
BlackIborCouponPricer_swigregister(BlackIborCouponPricer)

class CmsCoupon(FloatingRateCoupon):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_CmsCoupon(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CmsCoupon
    __del__ = lambda self: None
CmsCoupon_swigregister = _QuantLib.CmsCoupon_swigregister
CmsCoupon_swigregister(CmsCoupon)

class CmsCouponPricer(FloatingRateCouponPricer):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def swaptionVolatility(self):
        return _QuantLib.CmsCouponPricer_swaptionVolatility(self)

    def setSwaptionVolatility(self, *args):
        return _QuantLib.CmsCouponPricer_setSwaptionVolatility(self, *args)
    __swig_destroy__ = _QuantLib.delete_CmsCouponPricer
    __del__ = lambda self: None
CmsCouponPricer_swigregister = _QuantLib.CmsCouponPricer_swigregister
CmsCouponPricer_swigregister(CmsCouponPricer)

class GFunctionFactory(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Standard = _QuantLib.GFunctionFactory_Standard
    ExactYield = _QuantLib.GFunctionFactory_ExactYield
    ParallelShifts = _QuantLib.GFunctionFactory_ParallelShifts
    NonParallelShifts = _QuantLib.GFunctionFactory_NonParallelShifts
    __swig_destroy__ = _QuantLib.delete_GFunctionFactory
    __del__ = lambda self: None
GFunctionFactory_swigregister = _QuantLib.GFunctionFactory_swigregister
GFunctionFactory_swigregister(GFunctionFactory)

class AnalyticHaganPricer(CmsCouponPricer):
    thisown = _swig_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):
        this = _QuantLib.new_AnalyticHaganPricer(v, model, meanReversion)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticHaganPricer
    __del__ = lambda self: None
AnalyticHaganPricer_swigregister = _QuantLib.AnalyticHaganPricer_swigregister
AnalyticHaganPricer_swigregister(AnalyticHaganPricer)

class NumericHaganPricer(CmsCouponPricer):
    thisown = _swig_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):
        this = _QuantLib.new_NumericHaganPricer(v, model, meanReversion, lowerLimit, upperLimit, precision)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NumericHaganPricer
    __del__ = lambda self: None
NumericHaganPricer_swigregister = _QuantLib.NumericHaganPricer_swigregister
NumericHaganPricer_swigregister(NumericHaganPricer)

class CappedFlooredCmsCoupon(CappedFlooredCoupon):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CappedFlooredCmsCoupon(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CappedFlooredCmsCoupon
    __del__ = lambda self: None
CappedFlooredCmsCoupon_swigregister = _QuantLib.CappedFlooredCmsCoupon_swigregister
CappedFlooredCmsCoupon_swigregister(CappedFlooredCmsCoupon)

class LinearTsrPricer(CmsCouponPricer):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_LinearTsrPricer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_LinearTsrPricer
    __del__ = lambda self: None
LinearTsrPricer_swigregister = _QuantLib.LinearTsrPricer_swigregister
LinearTsrPricer_swigregister(LinearTsrPricer)


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

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

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

def CmsZeroLeg(*args, **kwargs):
    return _QuantLib.CmsZeroLeg(*args, **kwargs)
CmsZeroLeg = _QuantLib.CmsZeroLeg
class Duration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Simple = _QuantLib.Duration_Simple
    Macaulay = _QuantLib.Duration_Macaulay
    Modified = _QuantLib.Duration_Modified

    def __init__(self):
        this = _QuantLib.new_Duration()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Duration
    __del__ = lambda self: None
Duration_swigregister = _QuantLib.Duration_swigregister
Duration_swigregister(Duration)

class CashFlows(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    startDate = staticmethod(_QuantLib.CashFlows_startDate)
    maturityDate = staticmethod(_QuantLib.CashFlows_maturityDate)
    npv = staticmethod(_QuantLib.CashFlows_npv)
    bps = staticmethod(_QuantLib.CashFlows_bps)
    atmRate = staticmethod(_QuantLib.CashFlows_atmRate)
    yieldRate = staticmethod(_QuantLib.CashFlows_yieldRate)
    duration = staticmethod(_QuantLib.CashFlows_duration)
    convexity = staticmethod(_QuantLib.CashFlows_convexity)
    basisPointValue = staticmethod(_QuantLib.CashFlows_basisPointValue)
    zSpread = staticmethod(_QuantLib.CashFlows_zSpread)
    __swig_destroy__ = _QuantLib.delete_CashFlows
    __del__ = lambda self: None
CashFlows_swigregister = _QuantLib.CashFlows_swigregister
CashFlows_swigregister(CashFlows)

def CashFlows_startDate(arg2):
    return _QuantLib.CashFlows_startDate(arg2)
CashFlows_startDate = _QuantLib.CashFlows_startDate

def CashFlows_maturityDate(arg2):
    return _QuantLib.CashFlows_maturityDate(arg2)
CashFlows_maturityDate = _QuantLib.CashFlows_maturityDate

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

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

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

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

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

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

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

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

class CalibrationHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

    def __bool__(self):
        return _QuantLib.CalibrationHelper___bool__(self)
    RelativePriceError = _QuantLib.CalibrationHelper_RelativePriceError
    PriceError = _QuantLib.CalibrationHelper_PriceError
    ImpliedVolError = _QuantLib.CalibrationHelper_ImpliedVolError

    def swaptionExpiryDate(self):
        return _QuantLib.CalibrationHelper_swaptionExpiryDate(self)

    def swaptionStrike(self):
        return _QuantLib.CalibrationHelper_swaptionStrike(self)

    def swaptionNominal(self):
        return _QuantLib.CalibrationHelper_swaptionNominal(self)

    def swaptionMaturityDate(self):
        return _QuantLib.CalibrationHelper_swaptionMaturityDate(self)

    def __init__(self):
        this = _QuantLib.new_CalibrationHelper()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CalibrationHelper
    __del__ = lambda self: None

    def setPricingEngine(self, engine):
        return _QuantLib.CalibrationHelper_setPricingEngine(self, engine)

    def marketValue(self):
        return _QuantLib.CalibrationHelper_marketValue(self)

    def modelValue(self):
        return _QuantLib.CalibrationHelper_modelValue(self)

    def calibrationError(self):
        return _QuantLib.CalibrationHelper_calibrationError(self)

    def impliedVolatility(self, targetValue, accuracy, maxEvaluations, minVol, maxVol):
        return _QuantLib.CalibrationHelper_impliedVolatility(self, targetValue, accuracy, maxEvaluations, minVol, maxVol)

    def blackPrice(self, volatility):
        return _QuantLib.CalibrationHelper_blackPrice(self, volatility)

    def volatility(self):
        return _QuantLib.CalibrationHelper_volatility(self)

    def volatilityType(self):
        return _QuantLib.CalibrationHelper_volatilityType(self)
CalibrationHelper_swigregister = _QuantLib.CalibrationHelper_swigregister
CalibrationHelper_swigregister(CalibrationHelper)

class SwaptionHelper(CalibrationHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SwaptionHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def times(self):
        return _QuantLib.SwaptionHelper_times(self)
    __swig_destroy__ = _QuantLib.delete_SwaptionHelper
    __del__ = lambda self: None
SwaptionHelper_swigregister = _QuantLib.SwaptionHelper_swigregister
SwaptionHelper_swigregister(SwaptionHelper)

class CapHelper(CalibrationHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CapHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def times(self):
        return _QuantLib.CapHelper_times(self)
    __swig_destroy__ = _QuantLib.delete_CapHelper
    __del__ = lambda self: None
CapHelper_swigregister = _QuantLib.CapHelper_swigregister
CapHelper_swigregister(CapHelper)

class HestonModelHelper(CalibrationHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_HestonModelHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HestonModelHelper
    __del__ = lambda self: None
HestonModelHelper_swigregister = _QuantLib.HestonModelHelper_swigregister
HestonModelHelper_swigregister(HestonModelHelper)

class CalibrationHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.CalibrationHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_CalibrationHelperVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CalibrationHelperVector_swigregister = _QuantLib.CalibrationHelperVector_swigregister
CalibrationHelperVector_swigregister(CalibrationHelperVector)

class CalibratedModel(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.CalibratedModel_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_CalibratedModel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CalibratedModel
    __del__ = lambda self: None

    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)
CalibratedModel_swigregister = _QuantLib.CalibratedModel_swigregister
CalibratedModel_swigregister(CalibratedModel)

class CalibratedModelHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CalibratedModelHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.CalibratedModelHandle___deref__(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
    __del__ = lambda self: None

    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)
CalibratedModelHandle_swigregister = _QuantLib.CalibratedModelHandle_swigregister
CalibratedModelHandle_swigregister(CalibratedModelHandle)

class RelinkableCalibratedModelHandle(CalibratedModelHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableCalibratedModelHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableCalibratedModelHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableCalibratedModelHandle
    __del__ = lambda self: None
RelinkableCalibratedModelHandle_swigregister = _QuantLib.RelinkableCalibratedModelHandle_swigregister
RelinkableCalibratedModelHandle_swigregister(RelinkableCalibratedModelHandle)

class TimeGrid(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_TimeGrid(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
TimeGrid_swigregister = _QuantLib.TimeGrid_swigregister
TimeGrid_swigregister(TimeGrid)

class Parameter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_Parameter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Parameter_swigregister = _QuantLib.Parameter_swigregister
Parameter_swigregister(Parameter)

class ConstantParameter(Parameter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ConstantParameter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConstantParameter
    __del__ = lambda self: None
ConstantParameter_swigregister = _QuantLib.ConstantParameter_swigregister
ConstantParameter_swigregister(ConstantParameter)

class NullParameter(Parameter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_NullParameter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NullParameter
    __del__ = lambda self: None
NullParameter_swigregister = _QuantLib.NullParameter_swigregister
NullParameter_swigregister(NullParameter)

class PiecewiseConstantParameter(Parameter):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseConstantParameter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PiecewiseConstantParameter
    __del__ = lambda self: None
PiecewiseConstantParameter_swigregister = _QuantLib.PiecewiseConstantParameter_swigregister
PiecewiseConstantParameter_swigregister(PiecewiseConstantParameter)

class Option(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Put = _QuantLib.Option_Put
    Call = _QuantLib.Option_Call
    __swig_destroy__ = _QuantLib.delete_Option
    __del__ = lambda self: None
Option_swigregister = _QuantLib.Option_swigregister
Option_swigregister(Option)

class Barrier(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DownIn = _QuantLib.Barrier_DownIn
    UpIn = _QuantLib.Barrier_UpIn
    DownOut = _QuantLib.Barrier_DownOut
    UpOut = _QuantLib.Barrier_UpOut

    def __init__(self):
        this = _QuantLib.new_Barrier()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Barrier
    __del__ = lambda self: None
Barrier_swigregister = _QuantLib.Barrier_swigregister
Barrier_swigregister(Barrier)

class DoubleBarrier(object):
    thisown = _swig_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):
        this = _QuantLib.new_DoubleBarrier()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DoubleBarrier
    __del__ = lambda self: None
DoubleBarrier_swigregister = _QuantLib.DoubleBarrier_swigregister
DoubleBarrier_swigregister(DoubleBarrier)

class Payoff(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_Payoff()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Payoff
    __del__ = lambda self: None

    def __call__(self, price):
        return _QuantLib.Payoff___call__(self, price)
Payoff_swigregister = _QuantLib.Payoff_swigregister
Payoff_swigregister(Payoff)

class VanillaOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        this = _QuantLib.new_VanillaOption(payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def priceCurve(self):
        return _QuantLib.VanillaOption_priceCurve(self)

    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 delta(self):
        return _QuantLib.VanillaOption_delta(self)

    def gamma(self):
        return _QuantLib.VanillaOption_gamma(self)

    def theta(self):
        return _QuantLib.VanillaOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.VanillaOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.VanillaOption_vega(self)

    def rho(self):
        return _QuantLib.VanillaOption_rho(self)

    def dividendRho(self):
        return _QuantLib.VanillaOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.VanillaOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_VanillaOption
    __del__ = lambda self: None
VanillaOption_swigregister = _QuantLib.VanillaOption_swigregister
VanillaOption_swigregister(VanillaOption)

class EuropeanOption(VanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        this = _QuantLib.new_EuropeanOption(payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EuropeanOption
    __del__ = lambda self: None
EuropeanOption_swigregister = _QuantLib.EuropeanOption_swigregister
EuropeanOption_swigregister(EuropeanOption)

class ForwardVanillaOption(VanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, moneyness, resetDate, payoff, exercise):
        this = _QuantLib.new_ForwardVanillaOption(moneyness, resetDate, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardVanillaOption
    __del__ = lambda self: None
ForwardVanillaOption_swigregister = _QuantLib.ForwardVanillaOption_swigregister
ForwardVanillaOption_swigregister(ForwardVanillaOption)

class QuantoVanillaOption(VanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        this = _QuantLib.new_QuantoVanillaOption(payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def qvega(self):
        return _QuantLib.QuantoVanillaOption_qvega(self)

    def qrho(self):
        return _QuantLib.QuantoVanillaOption_qrho(self)

    def qlambda(self):
        return _QuantLib.QuantoVanillaOption_qlambda(self)
    __swig_destroy__ = _QuantLib.delete_QuantoVanillaOption
    __del__ = lambda self: None
QuantoVanillaOption_swigregister = _QuantLib.QuantoVanillaOption_swigregister
QuantoVanillaOption_swigregister(QuantoVanillaOption)

class QuantoForwardVanillaOption(QuantoVanillaOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, moneyness, resetDate, payoff, exercise):
        this = _QuantLib.new_QuantoForwardVanillaOption(moneyness, resetDate, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_QuantoForwardVanillaOption
    __del__ = lambda self: None
QuantoForwardVanillaOption_swigregister = _QuantLib.QuantoForwardVanillaOption_swigregister
QuantoForwardVanillaOption_swigregister(QuantoForwardVanillaOption)

class MultiAssetOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def delta(self):
        return _QuantLib.MultiAssetOption_delta(self)

    def gamma(self):
        return _QuantLib.MultiAssetOption_gamma(self)

    def theta(self):
        return _QuantLib.MultiAssetOption_theta(self)

    def vega(self):
        return _QuantLib.MultiAssetOption_vega(self)

    def rho(self):
        return _QuantLib.MultiAssetOption_rho(self)

    def dividendRho(self):
        return _QuantLib.MultiAssetOption_dividendRho(self)

    def __init__(self):
        this = _QuantLib.new_MultiAssetOption()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MultiAssetOption
    __del__ = lambda self: None
MultiAssetOption_swigregister = _QuantLib.MultiAssetOption_swigregister
MultiAssetOption_swigregister(MultiAssetOption)

class AnalyticEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticEuropeanEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticEuropeanEngine
    __del__ = lambda self: None
AnalyticEuropeanEngine_swigregister = _QuantLib.AnalyticEuropeanEngine_swigregister
AnalyticEuropeanEngine_swigregister(AnalyticEuropeanEngine)

class HestonModel(CalibratedModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_HestonModel(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
HestonModel_swigregister = _QuantLib.HestonModel_swigregister
HestonModel_swigregister(HestonModel)

class PiecewiseTimeDependentHestonModel(CalibratedModel):
    thisown = _swig_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):
        this = _QuantLib.new_PiecewiseTimeDependentHestonModel(riskFreeRate, dividendYield, s0, v0, theta, kappa, sigma, rho, timeGrid)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseTimeDependentHestonModel_swigregister = _QuantLib.PiecewiseTimeDependentHestonModel_swigregister
PiecewiseTimeDependentHestonModel_swigregister(PiecewiseTimeDependentHestonModel)

class AnalyticHestonEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_AnalyticHestonEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticHestonEngine
    __del__ = lambda self: None
AnalyticHestonEngine_swigregister = _QuantLib.AnalyticHestonEngine_swigregister
AnalyticHestonEngine_swigregister(AnalyticHestonEngine)

class AnalyticPTDHestonEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_AnalyticPTDHestonEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticPTDHestonEngine
    __del__ = lambda self: None
AnalyticPTDHestonEngine_swigregister = _QuantLib.AnalyticPTDHestonEngine_swigregister
AnalyticPTDHestonEngine_swigregister(AnalyticPTDHestonEngine)

class BatesModel(HestonModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_BatesModel(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
BatesModel_swigregister = _QuantLib.BatesModel_swigregister
BatesModel_swigregister(BatesModel)

class BatesEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BatesEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BatesEngine
    __del__ = lambda self: None
BatesEngine_swigregister = _QuantLib.BatesEngine_swigregister
BatesEngine_swigregister(BatesEngine)

class IntegralEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_IntegralEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IntegralEngine
    __del__ = lambda self: None
IntegralEngine_swigregister = _QuantLib.IntegralEngine_swigregister
IntegralEngine_swigregister(IntegralEngine)

class FDBermudanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        this = _QuantLib.new_FDBermudanEngine(process, timeSteps, gridPoints, timeDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FDBermudanEngine
    __del__ = lambda self: None
FDBermudanEngine_swigregister = _QuantLib.FDBermudanEngine_swigregister
FDBermudanEngine_swigregister(FDBermudanEngine)

class FDEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        this = _QuantLib.new_FDEuropeanEngine(process, timeSteps, gridPoints, timeDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FDEuropeanEngine
    __del__ = lambda self: None
FDEuropeanEngine_swigregister = _QuantLib.FDEuropeanEngine_swigregister
FDEuropeanEngine_swigregister(FDEuropeanEngine)

class BinomialVanillaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, type, steps):
        this = _QuantLib.new_BinomialVanillaEngine(process, type, steps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialVanillaEngine
    __del__ = lambda self: None
BinomialVanillaEngine_swigregister = _QuantLib.BinomialVanillaEngine_swigregister
BinomialVanillaEngine_swigregister(BinomialVanillaEngine)

class MCEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCEuropeanEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCEuropeanEngine
    __del__ = lambda self: None
MCEuropeanEngine_swigregister = _QuantLib.MCEuropeanEngine_swigregister
MCEuropeanEngine_swigregister(MCEuropeanEngine)

class FDAmericanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        this = _QuantLib.new_FDAmericanEngine(process, timeSteps, gridPoints, timeDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FDAmericanEngine
    __del__ = lambda self: None
FDAmericanEngine_swigregister = _QuantLib.FDAmericanEngine_swigregister
FDAmericanEngine_swigregister(FDAmericanEngine)

class FdBlackScholesVanillaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, tGrid=100, xGrid=100, dampingSteps=0):
        this = _QuantLib.new_FdBlackScholesVanillaEngine(process, tGrid, xGrid, dampingSteps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesVanillaEngine
    __del__ = lambda self: None
FdBlackScholesVanillaEngine_swigregister = _QuantLib.FdBlackScholesVanillaEngine_swigregister
FdBlackScholesVanillaEngine_swigregister(FdBlackScholesVanillaEngine)

class FdBatesVanillaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, model, tGrid=100, xGrid=100, vGrid=50, dampingSteps=0):
        this = _QuantLib.new_FdBatesVanillaEngine(model, tGrid, xGrid, vGrid, dampingSteps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FdBatesVanillaEngine
    __del__ = lambda self: None
FdBatesVanillaEngine_swigregister = _QuantLib.FdBatesVanillaEngine_swigregister
FdBatesVanillaEngine_swigregister(FdBatesVanillaEngine)

class ContinuousArithmeticAsianLevyEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, runningAverage, startDate):
        this = _QuantLib.new_ContinuousArithmeticAsianLevyEngine(process, runningAverage, startDate)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ContinuousArithmeticAsianLevyEngine
    __del__ = lambda self: None
ContinuousArithmeticAsianLevyEngine_swigregister = _QuantLib.ContinuousArithmeticAsianLevyEngine_swigregister
ContinuousArithmeticAsianLevyEngine_swigregister(ContinuousArithmeticAsianLevyEngine)

class FdBlackScholesAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, tGrid, xGrid, aGrid):
        this = _QuantLib.new_FdBlackScholesAsianEngine(process, tGrid, xGrid, aGrid)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesAsianEngine
    __del__ = lambda self: None
FdBlackScholesAsianEngine_swigregister = _QuantLib.FdBlackScholesAsianEngine_swigregister
FdBlackScholesAsianEngine_swigregister(FdBlackScholesAsianEngine)

class FDShoutEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        this = _QuantLib.new_FDShoutEngine(process, timeSteps, gridPoints, timeDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FDShoutEngine
    __del__ = lambda self: None
FDShoutEngine_swigregister = _QuantLib.FDShoutEngine_swigregister
FDShoutEngine_swigregister(FDShoutEngine)

class BaroneAdesiWhaleyEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_BaroneAdesiWhaleyEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BaroneAdesiWhaleyEngine
    __del__ = lambda self: None
BaroneAdesiWhaleyEngine_swigregister = _QuantLib.BaroneAdesiWhaleyEngine_swigregister
BaroneAdesiWhaleyEngine_swigregister(BaroneAdesiWhaleyEngine)

class BjerksundStenslandEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_BjerksundStenslandEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BjerksundStenslandEngine
    __del__ = lambda self: None
BjerksundStenslandEngine_swigregister = _QuantLib.BjerksundStenslandEngine_swigregister
BjerksundStenslandEngine_swigregister(BjerksundStenslandEngine)

class AnalyticDigitalAmericanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticDigitalAmericanEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanEngine
    __del__ = lambda self: None
AnalyticDigitalAmericanEngine_swigregister = _QuantLib.AnalyticDigitalAmericanEngine_swigregister
AnalyticDigitalAmericanEngine_swigregister(AnalyticDigitalAmericanEngine)

class AnalyticDigitalAmericanKOEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticDigitalAmericanKOEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDigitalAmericanKOEngine
    __del__ = lambda self: None
AnalyticDigitalAmericanKOEngine_swigregister = _QuantLib.AnalyticDigitalAmericanKOEngine_swigregister
AnalyticDigitalAmericanKOEngine_swigregister(AnalyticDigitalAmericanKOEngine)

class DividendVanillaOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise, dividendDates, dividends):
        this = _QuantLib.new_DividendVanillaOption(payoff, exercise, dividendDates, dividends)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def priceCurve(self):
        return _QuantLib.DividendVanillaOption_priceCurve(self)

    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)

    def delta(self):
        return _QuantLib.DividendVanillaOption_delta(self)

    def gamma(self):
        return _QuantLib.DividendVanillaOption_gamma(self)

    def theta(self):
        return _QuantLib.DividendVanillaOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.DividendVanillaOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.DividendVanillaOption_vega(self)

    def rho(self):
        return _QuantLib.DividendVanillaOption_rho(self)

    def dividendRho(self):
        return _QuantLib.DividendVanillaOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.DividendVanillaOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_DividendVanillaOption
    __del__ = lambda self: None
DividendVanillaOption_swigregister = _QuantLib.DividendVanillaOption_swigregister
DividendVanillaOption_swigregister(DividendVanillaOption)

class AnalyticDividendEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticDividendEuropeanEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDividendEuropeanEngine
    __del__ = lambda self: None
AnalyticDividendEuropeanEngine_swigregister = _QuantLib.AnalyticDividendEuropeanEngine_swigregister
AnalyticDividendEuropeanEngine_swigregister(AnalyticDividendEuropeanEngine)

class FDDividendEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        this = _QuantLib.new_FDDividendEuropeanEngine(process, timeSteps, gridPoints, timeDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FDDividendEuropeanEngine
    __del__ = lambda self: None
FDDividendEuropeanEngine_swigregister = _QuantLib.FDDividendEuropeanEngine_swigregister
FDDividendEuropeanEngine_swigregister(FDDividendEuropeanEngine)

class FDDividendAmericanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, timeSteps=100, gridPoints=100, timeDependent=False):
        this = _QuantLib.new_FDDividendAmericanEngine(process, timeSteps, gridPoints, timeDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FDDividendAmericanEngine
    __del__ = lambda self: None
FDDividendAmericanEngine_swigregister = _QuantLib.FDDividendAmericanEngine_swigregister
FDDividendAmericanEngine_swigregister(FDDividendAmericanEngine)

class BarrierOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, barrierType, barrier, rebate, payoff, exercise):
        this = _QuantLib.new_BarrierOption(barrierType, barrier, rebate, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def priceCurve(self):
        return _QuantLib.BarrierOption_priceCurve(self)

    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)

    def delta(self):
        return _QuantLib.BarrierOption_delta(self)

    def gamma(self):
        return _QuantLib.BarrierOption_gamma(self)

    def theta(self):
        return _QuantLib.BarrierOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.BarrierOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.BarrierOption_vega(self)

    def rho(self):
        return _QuantLib.BarrierOption_rho(self)

    def dividendRho(self):
        return _QuantLib.BarrierOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.BarrierOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_BarrierOption
    __del__ = lambda self: None
BarrierOption_swigregister = _QuantLib.BarrierOption_swigregister
BarrierOption_swigregister(BarrierOption)

class AnalyticBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticBarrierEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticBarrierEngine
    __del__ = lambda self: None
AnalyticBarrierEngine_swigregister = _QuantLib.AnalyticBarrierEngine_swigregister
AnalyticBarrierEngine_swigregister(AnalyticBarrierEngine)

class MCBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCBarrierEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCBarrierEngine
    __del__ = lambda self: None
MCBarrierEngine_swigregister = _QuantLib.MCBarrierEngine_swigregister
MCBarrierEngine_swigregister(MCBarrierEngine)

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

    def __init__(self, type, theta, mu):
        this = _QuantLib.new_FdmSchemeDesc(type, theta, mu)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    type = _swig_property(_QuantLib.FdmSchemeDesc_type_get)
    theta = _swig_property(_QuantLib.FdmSchemeDesc_theta_get)
    mu = _swig_property(_QuantLib.FdmSchemeDesc_mu_get)
    Douglas = staticmethod(_QuantLib.FdmSchemeDesc_Douglas)
    ImplicitEuler = staticmethod(_QuantLib.FdmSchemeDesc_ImplicitEuler)
    ExplicitEuler = staticmethod(_QuantLib.FdmSchemeDesc_ExplicitEuler)
    CraigSneyd = staticmethod(_QuantLib.FdmSchemeDesc_CraigSneyd)
    ModifiedCraigSneyd = staticmethod(_QuantLib.FdmSchemeDesc_ModifiedCraigSneyd)
    Hundsdorfer = staticmethod(_QuantLib.FdmSchemeDesc_Hundsdorfer)
    ModifiedHundsdorfer = staticmethod(_QuantLib.FdmSchemeDesc_ModifiedHundsdorfer)
    __swig_destroy__ = _QuantLib.delete_FdmSchemeDesc
    __del__ = lambda self: None
FdmSchemeDesc_swigregister = _QuantLib.FdmSchemeDesc_swigregister
FdmSchemeDesc_swigregister(FdmSchemeDesc)

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

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

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

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

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

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

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

class FdBlackScholesBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FdBlackScholesBarrierEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FdBlackScholesBarrierEngine
    __del__ = lambda self: None
FdBlackScholesBarrierEngine_swigregister = _QuantLib.FdBlackScholesBarrierEngine_swigregister
FdBlackScholesBarrierEngine_swigregister(FdBlackScholesBarrierEngine)

class AnalyticBinaryBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticBinaryBarrierEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticBinaryBarrierEngine
    __del__ = lambda self: None
AnalyticBinaryBarrierEngine_swigregister = _QuantLib.AnalyticBinaryBarrierEngine_swigregister
AnalyticBinaryBarrierEngine_swigregister(AnalyticBinaryBarrierEngine)

class BinomialBarrierEngine(PricingEngine):
    """
    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 = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, type, steps, max_steps=0):
        """
        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.

        """
        this = _QuantLib.new_BinomialBarrierEngine(process, type, steps, max_steps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialBarrierEngine
    __del__ = lambda self: None
BinomialBarrierEngine_swigregister = _QuantLib.BinomialBarrierEngine_swigregister
BinomialBarrierEngine_swigregister(BinomialBarrierEngine)

class ForwardEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_ForwardEuropeanEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardEuropeanEngine
    __del__ = lambda self: None
ForwardEuropeanEngine_swigregister = _QuantLib.ForwardEuropeanEngine_swigregister
ForwardEuropeanEngine_swigregister(ForwardEuropeanEngine)

class QuantoEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        this = _QuantLib.new_QuantoEuropeanEngine(process, foreignRiskFreeRate, exchangeRateVolatility, correlation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_QuantoEuropeanEngine
    __del__ = lambda self: None
QuantoEuropeanEngine_swigregister = _QuantLib.QuantoEuropeanEngine_swigregister
QuantoEuropeanEngine_swigregister(QuantoEuropeanEngine)

class QuantoForwardEuropeanEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, foreignRiskFreeRate, exchangeRateVolatility, correlation):
        this = _QuantLib.new_QuantoForwardEuropeanEngine(process, foreignRiskFreeRate, exchangeRateVolatility, correlation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_QuantoForwardEuropeanEngine
    __del__ = lambda self: None
QuantoForwardEuropeanEngine_swigregister = _QuantLib.QuantoForwardEuropeanEngine_swigregister
QuantoForwardEuropeanEngine_swigregister(QuantoForwardEuropeanEngine)

class BlackCalculator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, payoff, forward, stdDev, discount=1.0):
        this = _QuantLib.new_BlackCalculator(payoff, forward, stdDev, discount)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
BlackCalculator_swigregister = _QuantLib.BlackCalculator_swigregister
BlackCalculator_swigregister(BlackCalculator)

class Average(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Arithmetic = _QuantLib.Average_Arithmetic
    Geometric = _QuantLib.Average_Geometric

    def __init__(self):
        this = _QuantLib.new_Average()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Average
    __del__ = lambda self: None
Average_swigregister = _QuantLib.Average_swigregister
Average_swigregister(Average)

class ContinuousAveragingAsianOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, averageType, payoff, exercise):
        this = _QuantLib.new_ContinuousAveragingAsianOption(averageType, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def delta(self):
        return _QuantLib.ContinuousAveragingAsianOption_delta(self)

    def gamma(self):
        return _QuantLib.ContinuousAveragingAsianOption_gamma(self)

    def theta(self):
        return _QuantLib.ContinuousAveragingAsianOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.ContinuousAveragingAsianOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.ContinuousAveragingAsianOption_vega(self)

    def rho(self):
        return _QuantLib.ContinuousAveragingAsianOption_rho(self)

    def dividendRho(self):
        return _QuantLib.ContinuousAveragingAsianOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.ContinuousAveragingAsianOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_ContinuousAveragingAsianOption
    __del__ = lambda self: None
ContinuousAveragingAsianOption_swigregister = _QuantLib.ContinuousAveragingAsianOption_swigregister
ContinuousAveragingAsianOption_swigregister(ContinuousAveragingAsianOption)

class DiscreteAveragingAsianOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, averageType, runningAccumulator, pastFixings, fixingDates, payoff, exercise):
        this = _QuantLib.new_DiscreteAveragingAsianOption(averageType, runningAccumulator, pastFixings, fixingDates, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def delta(self):
        return _QuantLib.DiscreteAveragingAsianOption_delta(self)

    def gamma(self):
        return _QuantLib.DiscreteAveragingAsianOption_gamma(self)

    def theta(self):
        return _QuantLib.DiscreteAveragingAsianOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.DiscreteAveragingAsianOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.DiscreteAveragingAsianOption_vega(self)

    def rho(self):
        return _QuantLib.DiscreteAveragingAsianOption_rho(self)

    def dividendRho(self):
        return _QuantLib.DiscreteAveragingAsianOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.DiscreteAveragingAsianOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_DiscreteAveragingAsianOption
    __del__ = lambda self: None
DiscreteAveragingAsianOption_swigregister = _QuantLib.DiscreteAveragingAsianOption_swigregister
DiscreteAveragingAsianOption_swigregister(DiscreteAveragingAsianOption)

class AnalyticContinuousGeometricAveragePriceAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticContinuousGeometricAveragePriceAsianEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticContinuousGeometricAveragePriceAsianEngine
    __del__ = lambda self: None
AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister = _QuantLib.AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister
AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister(AnalyticContinuousGeometricAveragePriceAsianEngine)

class AnalyticDiscreteGeometricAveragePriceAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticDiscreteGeometricAveragePriceAsianEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAveragePriceAsianEngine
    __del__ = lambda self: None
AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister = _QuantLib.AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister
AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister(AnalyticDiscreteGeometricAveragePriceAsianEngine)

class AnalyticDiscreteGeometricAverageStrikeAsianEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine
    __del__ = lambda self: None
AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister = _QuantLib.AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister
AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister(AnalyticDiscreteGeometricAverageStrikeAsianEngine)

class MCDiscreteArithmeticAPEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCDiscreteArithmeticAPEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCDiscreteArithmeticAPEngine
    __del__ = lambda self: None
MCDiscreteArithmeticAPEngine_swigregister = _QuantLib.MCDiscreteArithmeticAPEngine_swigregister
MCDiscreteArithmeticAPEngine_swigregister(MCDiscreteArithmeticAPEngine)

class MCDiscreteArithmeticASEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCDiscreteArithmeticASEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCDiscreteArithmeticASEngine
    __del__ = lambda self: None
MCDiscreteArithmeticASEngine_swigregister = _QuantLib.MCDiscreteArithmeticASEngine_swigregister
MCDiscreteArithmeticASEngine_swigregister(MCDiscreteArithmeticASEngine)

class MCDiscreteGeometricAPEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCDiscreteGeometricAPEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCDiscreteGeometricAPEngine
    __del__ = lambda self: None
MCDiscreteGeometricAPEngine_swigregister = _QuantLib.MCDiscreteGeometricAPEngine_swigregister
MCDiscreteGeometricAPEngine_swigregister(MCDiscreteGeometricAPEngine)

class VarianceGammaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_VarianceGammaEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_VarianceGammaEngine
    __del__ = lambda self: None
VarianceGammaEngine_swigregister = _QuantLib.VarianceGammaEngine_swigregister
VarianceGammaEngine_swigregister(VarianceGammaEngine)

class FFTVarianceGammaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, logStrikeSpacing=0.001):
        this = _QuantLib.new_FFTVarianceGammaEngine(process, logStrikeSpacing)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def precalculate(self, optionList):
        return _QuantLib.FFTVarianceGammaEngine_precalculate(self, optionList)
    __swig_destroy__ = _QuantLib.delete_FFTVarianceGammaEngine
    __del__ = lambda self: None
FFTVarianceGammaEngine_swigregister = _QuantLib.FFTVarianceGammaEngine_swigregister
FFTVarianceGammaEngine_swigregister(FFTVarianceGammaEngine)

class DoubleBarrierOption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise):
        this = _QuantLib.new_DoubleBarrierOption(barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def delta(self):
        return _QuantLib.DoubleBarrierOption_delta(self)

    def gamma(self):
        return _QuantLib.DoubleBarrierOption_gamma(self)

    def theta(self):
        return _QuantLib.DoubleBarrierOption_theta(self)

    def thetaPerDay(self):
        return _QuantLib.DoubleBarrierOption_thetaPerDay(self)

    def vega(self):
        return _QuantLib.DoubleBarrierOption_vega(self)

    def rho(self):
        return _QuantLib.DoubleBarrierOption_rho(self)

    def dividendRho(self):
        return _QuantLib.DoubleBarrierOption_dividendRho(self)

    def strikeSensitivity(self):
        return _QuantLib.DoubleBarrierOption_strikeSensitivity(self)
    __swig_destroy__ = _QuantLib.delete_DoubleBarrierOption
    __del__ = lambda self: None
DoubleBarrierOption_swigregister = _QuantLib.DoubleBarrierOption_swigregister
DoubleBarrierOption_swigregister(DoubleBarrierOption)

class QuantoDoubleBarrierOption(DoubleBarrierOption):
    thisown = _swig_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):
        this = _QuantLib.new_QuantoDoubleBarrierOption(barrierType, barrier_lo, barrier_hi, rebate, payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
QuantoDoubleBarrierOption_swigregister = _QuantLib.QuantoDoubleBarrierOption_swigregister
QuantoDoubleBarrierOption_swigregister(QuantoDoubleBarrierOption)

class AnalyticDoubleBarrierEngine(PricingEngine):
    """Double barrier engine implementing Ikeda-Kunitomo series."""

    thisown = _swig_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):
        """Double barrier engine implementing Ikeda-Kunitomo series."""
        this = _QuantLib.new_AnalyticDoubleBarrierEngine(process, series)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDoubleBarrierEngine
    __del__ = lambda self: None
AnalyticDoubleBarrierEngine_swigregister = _QuantLib.AnalyticDoubleBarrierEngine_swigregister
AnalyticDoubleBarrierEngine_swigregister(AnalyticDoubleBarrierEngine)

class WulinYongDoubleBarrierEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, series=5):
        this = _QuantLib.new_WulinYongDoubleBarrierEngine(process, series)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_WulinYongDoubleBarrierEngine
    __del__ = lambda self: None
WulinYongDoubleBarrierEngine_swigregister = _QuantLib.WulinYongDoubleBarrierEngine_swigregister
WulinYongDoubleBarrierEngine_swigregister(WulinYongDoubleBarrierEngine)

class DeltaVolQuote(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.DeltaVolQuote_asObservable(self)
    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):
        this = _QuantLib.new_DeltaVolQuote(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DeltaVolQuote
    __del__ = lambda self: None

    def value(self):
        return _QuantLib.DeltaVolQuote_value(self)
DeltaVolQuote_swigregister = _QuantLib.DeltaVolQuote_swigregister
DeltaVolQuote_swigregister(DeltaVolQuote)

class DeltaVolQuoteHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DeltaVolQuoteHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.DeltaVolQuoteHandle___deref__(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
    __del__ = lambda self: None

    def value(self):
        return _QuantLib.DeltaVolQuoteHandle_value(self)
DeltaVolQuoteHandle_swigregister = _QuantLib.DeltaVolQuoteHandle_swigregister
DeltaVolQuoteHandle_swigregister(DeltaVolQuoteHandle)

class RelinkableDeltaVolQuoteHandle(DeltaVolQuoteHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableDeltaVolQuoteHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableDeltaVolQuoteHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableDeltaVolQuoteHandle
    __del__ = lambda self: None
RelinkableDeltaVolQuoteHandle_swigregister = _QuantLib.RelinkableDeltaVolQuoteHandle_swigregister
RelinkableDeltaVolQuoteHandle_swigregister(RelinkableDeltaVolQuoteHandle)

class VannaVolgaDoubleBarrierEngine(PricingEngine):
    """

    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 = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """

        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

        """
        this = _QuantLib.new_VannaVolgaDoubleBarrierEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_VannaVolgaDoubleBarrierEngine
    __del__ = lambda self: None
VannaVolgaDoubleBarrierEngine_swigregister = _QuantLib.VannaVolgaDoubleBarrierEngine_swigregister
VannaVolgaDoubleBarrierEngine_swigregister(VannaVolgaDoubleBarrierEngine)

class AnalyticDoubleBarrierBinaryEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process):
        this = _QuantLib.new_AnalyticDoubleBarrierBinaryEngine(process)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticDoubleBarrierBinaryEngine
    __del__ = lambda self: None
AnalyticDoubleBarrierBinaryEngine_swigregister = _QuantLib.AnalyticDoubleBarrierBinaryEngine_swigregister
AnalyticDoubleBarrierBinaryEngine_swigregister(AnalyticDoubleBarrierBinaryEngine)

class BinomialDoubleBarrierEngine(PricingEngine):
    """
    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 = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, type, steps):
        """
        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

        """
        this = _QuantLib.new_BinomialDoubleBarrierEngine(process, type, steps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialDoubleBarrierEngine
    __del__ = lambda self: None
BinomialDoubleBarrierEngine_swigregister = _QuantLib.BinomialDoubleBarrierEngine_swigregister
BinomialDoubleBarrierEngine_swigregister(BinomialDoubleBarrierEngine)

class PlainVanillaPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, type, strike):
        this = _QuantLib.new_PlainVanillaPayoff(type, strike)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def optionType(self):
        return _QuantLib.PlainVanillaPayoff_optionType(self)

    def strike(self):
        return _QuantLib.PlainVanillaPayoff_strike(self)
    __swig_destroy__ = _QuantLib.delete_PlainVanillaPayoff
    __del__ = lambda self: None
PlainVanillaPayoff_swigregister = _QuantLib.PlainVanillaPayoff_swigregister
PlainVanillaPayoff_swigregister(PlainVanillaPayoff)

class PercentageStrikePayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, type, moneyness):
        this = _QuantLib.new_PercentageStrikePayoff(type, moneyness)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_PercentageStrikePayoff
    __del__ = lambda self: None
PercentageStrikePayoff_swigregister = _QuantLib.PercentageStrikePayoff_swigregister
PercentageStrikePayoff_swigregister(PercentageStrikePayoff)

class CashOrNothingPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, type, strike, payoff):
        this = _QuantLib.new_CashOrNothingPayoff(type, strike, payoff)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CashOrNothingPayoff
    __del__ = lambda self: None
CashOrNothingPayoff_swigregister = _QuantLib.CashOrNothingPayoff_swigregister
CashOrNothingPayoff_swigregister(CashOrNothingPayoff)

class AssetOrNothingPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, type, strike):
        this = _QuantLib.new_AssetOrNothingPayoff(type, strike)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AssetOrNothingPayoff
    __del__ = lambda self: None
AssetOrNothingPayoff_swigregister = _QuantLib.AssetOrNothingPayoff_swigregister
AssetOrNothingPayoff_swigregister(AssetOrNothingPayoff)

class SuperSharePayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, type, strike, increment):
        this = _QuantLib.new_SuperSharePayoff(type, strike, increment)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SuperSharePayoff
    __del__ = lambda self: None
SuperSharePayoff_swigregister = _QuantLib.SuperSharePayoff_swigregister
SuperSharePayoff_swigregister(SuperSharePayoff)

class GapPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, type, strike, strikePayoff):
        this = _QuantLib.new_GapPayoff(type, strike, strikePayoff)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GapPayoff
    __del__ = lambda self: None
GapPayoff_swigregister = _QuantLib.GapPayoff_swigregister
GapPayoff_swigregister(GapPayoff)

class BasketPayoff(Payoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_BasketPayoff()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BasketPayoff
    __del__ = lambda self: None
BasketPayoff_swigregister = _QuantLib.BasketPayoff_swigregister
BasketPayoff_swigregister(BasketPayoff)

class MinBasketPayoff(BasketPayoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, p):
        this = _QuantLib.new_MinBasketPayoff(p)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MinBasketPayoff
    __del__ = lambda self: None
MinBasketPayoff_swigregister = _QuantLib.MinBasketPayoff_swigregister
MinBasketPayoff_swigregister(MinBasketPayoff)

class MaxBasketPayoff(BasketPayoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, p):
        this = _QuantLib.new_MaxBasketPayoff(p)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MaxBasketPayoff
    __del__ = lambda self: None
MaxBasketPayoff_swigregister = _QuantLib.MaxBasketPayoff_swigregister
MaxBasketPayoff_swigregister(MaxBasketPayoff)

class AverageBasketPayoff(BasketPayoff):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_AverageBasketPayoff(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AverageBasketPayoff
    __del__ = lambda self: None
AverageBasketPayoff_swigregister = _QuantLib.AverageBasketPayoff_swigregister
AverageBasketPayoff_swigregister(AverageBasketPayoff)

class BasketOption(MultiAssetOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, payoff, exercise):
        this = _QuantLib.new_BasketOption(payoff, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BasketOption
    __del__ = lambda self: None
BasketOption_swigregister = _QuantLib.BasketOption_swigregister
BasketOption_swigregister(BasketOption)

class MCEuropeanBasketEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCEuropeanBasketEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCEuropeanBasketEngine
    __del__ = lambda self: None
MCEuropeanBasketEngine_swigregister = _QuantLib.MCEuropeanBasketEngine_swigregister
MCEuropeanBasketEngine_swigregister(MCEuropeanBasketEngine)

class MCAmericanBasketEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCAmericanBasketEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCAmericanBasketEngine
    __del__ = lambda self: None
MCAmericanBasketEngine_swigregister = _QuantLib.MCAmericanBasketEngine_swigregister
MCAmericanBasketEngine_swigregister(MCAmericanBasketEngine)

class StulzEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process1, process2, correlation):
        this = _QuantLib.new_StulzEngine(process1, process2, correlation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_StulzEngine
    __del__ = lambda self: None
StulzEngine_swigregister = _QuantLib.StulzEngine_swigregister
StulzEngine_swigregister(StulzEngine)

class EverestOption(MultiAssetOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, notional, guarantee, exercise):
        this = _QuantLib.new_EverestOption(notional, guarantee, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EverestOption
    __del__ = lambda self: None
EverestOption_swigregister = _QuantLib.EverestOption_swigregister
EverestOption_swigregister(EverestOption)

class MCEverestEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCEverestEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCEverestEngine
    __del__ = lambda self: None
MCEverestEngine_swigregister = _QuantLib.MCEverestEngine_swigregister
MCEverestEngine_swigregister(MCEverestEngine)

class HimalayaOption(MultiAssetOption):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, fixingDates, strike):
        this = _QuantLib.new_HimalayaOption(fixingDates, strike)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HimalayaOption
    __del__ = lambda self: None
HimalayaOption_swigregister = _QuantLib.HimalayaOption_swigregister
HimalayaOption_swigregister(HimalayaOption)

class MCHimalayaEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_MCHimalayaEngine(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MCHimalayaEngine
    __del__ = lambda self: None
MCHimalayaEngine_swigregister = _QuantLib.MCHimalayaEngine_swigregister
MCHimalayaEngine_swigregister(MCHimalayaEngine)


def blackFormula(optionType, strike, forward, stdDev, discount=1.0, displacement=0.0):
    return _QuantLib.blackFormula(optionType, strike, forward, stdDev, discount, displacement)
blackFormula = _QuantLib.blackFormula

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

def blackFormulaCashItmProbability(optionType, strike, forward, stdDev, displacement=0.0):
    return _QuantLib.blackFormulaCashItmProbability(optionType, strike, forward, stdDev, displacement)
blackFormulaCashItmProbability = _QuantLib.blackFormulaCashItmProbability

def bachelierBlackFormula(optionType, strike, forward, stdDev, discount=1.0):
    return _QuantLib.bachelierBlackFormula(optionType, strike, forward, stdDev, discount)
bachelierBlackFormula = _QuantLib.bachelierBlackFormula

def bachelierBlackFormulaImpliedVol(optionType, strike, forward, tte, bachelierPrice, discount=1.0):
    return _QuantLib.bachelierBlackFormulaImpliedVol(optionType, strike, forward, tte, bachelierPrice, discount)
bachelierBlackFormulaImpliedVol = _QuantLib.bachelierBlackFormulaImpliedVol
class BlackDeltaCalculator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ot, dt, spot, dDiscount, fDiscount, stDev):
        this = _QuantLib.new_BlackDeltaCalculator(ot, dt, spot, dDiscount, fDiscount, stDev)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
BlackDeltaCalculator_swigregister = _QuantLib.BlackDeltaCalculator_swigregister
BlackDeltaCalculator_swigregister(BlackDeltaCalculator)

class CallabilityPrice(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Dirty = _QuantLib.CallabilityPrice_Dirty
    Clean = _QuantLib.CallabilityPrice_Clean

    def __init__(self, amount, type):
        this = _QuantLib.new_CallabilityPrice(amount, type)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def amount(self):
        return _QuantLib.CallabilityPrice_amount(self)

    def type(self):
        return _QuantLib.CallabilityPrice_type(self)
    __swig_destroy__ = _QuantLib.delete_CallabilityPrice
    __del__ = lambda self: None
CallabilityPrice_swigregister = _QuantLib.CallabilityPrice_swigregister
CallabilityPrice_swigregister(CallabilityPrice)

class Callability(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self, price, type, date):
        this = _QuantLib.new_Callability(price, type, date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    Call = _QuantLib.Callability_Call
    Put = _QuantLib.Callability_Put
    __swig_destroy__ = _QuantLib.delete_Callability
    __del__ = lambda self: None

    def price(self):
        return _QuantLib.Callability_price(self)

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

    def date(self):
        return _QuantLib.Callability_date(self)
Callability_swigregister = _QuantLib.Callability_swigregister
Callability_swigregister(Callability)

class SoftCallability(Callability):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, price, date, trigger):
        this = _QuantLib.new_SoftCallability(price, date, trigger)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SoftCallability
    __del__ = lambda self: None
SoftCallability_swigregister = _QuantLib.SoftCallability_swigregister
SoftCallability_swigregister(SoftCallability)

class CallabilitySchedule(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.CallabilitySchedule_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_CallabilitySchedule(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CallabilitySchedule_swigregister = _QuantLib.CallabilitySchedule_swigregister
CallabilitySchedule_swigregister(CallabilitySchedule)

class Seasonality(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_Seasonality()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Seasonality
    __del__ = lambda self: None

    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)
Seasonality_swigregister = _QuantLib.Seasonality_swigregister
Seasonality_swigregister(Seasonality)

class MultiplicativePriceSeasonalityPtr(Seasonality):
    thisown = _swig_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):
        this = _QuantLib.new_MultiplicativePriceSeasonalityPtr(seasonalityBaseDate, frequency, seasonalityFactors)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MultiplicativePriceSeasonalityPtr
    __del__ = lambda self: None
MultiplicativePriceSeasonalityPtr_swigregister = _QuantLib.MultiplicativePriceSeasonalityPtr_swigregister
MultiplicativePriceSeasonalityPtr_swigregister(MultiplicativePriceSeasonalityPtr)

class YoYInflationTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.YoYInflationTermStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_YoYInflationTermStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YoYInflationTermStructure
    __del__ = lambda self: None

    def yoyRate(self, *args):
        return _QuantLib.YoYInflationTermStructure_yoyRate(self, *args)

    def dayCounter(self):
        return _QuantLib.YoYInflationTermStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.YoYInflationTermStructure_calendar(self)

    def referenceDate(self):
        return _QuantLib.YoYInflationTermStructure_referenceDate(self)

    def maxDate(self):
        return _QuantLib.YoYInflationTermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.YoYInflationTermStructure_maxTime(self)

    def observationLag(self):
        return _QuantLib.YoYInflationTermStructure_observationLag(self)

    def frequency(self):
        return _QuantLib.YoYInflationTermStructure_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.YoYInflationTermStructure_indexIsInterpolated(self)

    def baseRate(self):
        return _QuantLib.YoYInflationTermStructure_baseRate(self)

    def nominalTermStructure(self):
        return _QuantLib.YoYInflationTermStructure_nominalTermStructure(self)

    def baseDate(self):
        return _QuantLib.YoYInflationTermStructure_baseDate(self)

    def setSeasonality(self, *args):
        return _QuantLib.YoYInflationTermStructure_setSeasonality(self, *args)

    def seasonality(self):
        return _QuantLib.YoYInflationTermStructure_seasonality(self)

    def hasSeasonality(self):
        return _QuantLib.YoYInflationTermStructure_hasSeasonality(self)

    def enableExtrapolation(self):
        return _QuantLib.YoYInflationTermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YoYInflationTermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YoYInflationTermStructure_allowsExtrapolation(self)
YoYInflationTermStructure_swigregister = _QuantLib.YoYInflationTermStructure_swigregister
YoYInflationTermStructure_swigregister(YoYInflationTermStructure)

class YoYInflationTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YoYInflationTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.YoYInflationTermStructureHandle___deref__(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
    __del__ = lambda self: None

    def yoyRate(self, *args):
        return _QuantLib.YoYInflationTermStructureHandle_yoyRate(self, *args)

    def dayCounter(self):
        return _QuantLib.YoYInflationTermStructureHandle_dayCounter(self)

    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 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 enableExtrapolation(self):
        return _QuantLib.YoYInflationTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.YoYInflationTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.YoYInflationTermStructureHandle_allowsExtrapolation(self)
YoYInflationTermStructureHandle_swigregister = _QuantLib.YoYInflationTermStructureHandle_swigregister
YoYInflationTermStructureHandle_swigregister(YoYInflationTermStructureHandle)

class RelinkableYoYInflationTermStructureHandle(YoYInflationTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableYoYInflationTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableYoYInflationTermStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableYoYInflationTermStructureHandle
    __del__ = lambda self: None
RelinkableYoYInflationTermStructureHandle_swigregister = _QuantLib.RelinkableYoYInflationTermStructureHandle_swigregister
RelinkableYoYInflationTermStructureHandle_swigregister(RelinkableYoYInflationTermStructureHandle)

class ZeroInflationTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.ZeroInflationTermStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_ZeroInflationTermStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroInflationTermStructure
    __del__ = lambda self: None

    def zeroRate(self, *args):
        return _QuantLib.ZeroInflationTermStructure_zeroRate(self, *args)

    def dayCounter(self):
        return _QuantLib.ZeroInflationTermStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.ZeroInflationTermStructure_calendar(self)

    def referenceDate(self):
        return _QuantLib.ZeroInflationTermStructure_referenceDate(self)

    def maxDate(self):
        return _QuantLib.ZeroInflationTermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.ZeroInflationTermStructure_maxTime(self)

    def observationLag(self):
        return _QuantLib.ZeroInflationTermStructure_observationLag(self)

    def frequency(self):
        return _QuantLib.ZeroInflationTermStructure_frequency(self)

    def indexIsInterpolated(self):
        return _QuantLib.ZeroInflationTermStructure_indexIsInterpolated(self)

    def baseRate(self):
        return _QuantLib.ZeroInflationTermStructure_baseRate(self)

    def nominalTermStructure(self):
        return _QuantLib.ZeroInflationTermStructure_nominalTermStructure(self)

    def baseDate(self):
        return _QuantLib.ZeroInflationTermStructure_baseDate(self)

    def setSeasonality(self, *args):
        return _QuantLib.ZeroInflationTermStructure_setSeasonality(self, *args)

    def seasonality(self):
        return _QuantLib.ZeroInflationTermStructure_seasonality(self)

    def hasSeasonality(self):
        return _QuantLib.ZeroInflationTermStructure_hasSeasonality(self)

    def enableExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructure_allowsExtrapolation(self)
ZeroInflationTermStructure_swigregister = _QuantLib.ZeroInflationTermStructure_swigregister
ZeroInflationTermStructure_swigregister(ZeroInflationTermStructure)

class ZeroInflationTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ZeroInflationTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.ZeroInflationTermStructureHandle___deref__(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
    __del__ = lambda self: None

    def zeroRate(self, *args):
        return _QuantLib.ZeroInflationTermStructureHandle_zeroRate(self, *args)

    def dayCounter(self):
        return _QuantLib.ZeroInflationTermStructureHandle_dayCounter(self)

    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 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 enableExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.ZeroInflationTermStructureHandle_allowsExtrapolation(self)
ZeroInflationTermStructureHandle_swigregister = _QuantLib.ZeroInflationTermStructureHandle_swigregister
ZeroInflationTermStructureHandle_swigregister(ZeroInflationTermStructureHandle)

class RelinkableZeroInflationTermStructureHandle(ZeroInflationTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableZeroInflationTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableZeroInflationTermStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableZeroInflationTermStructureHandle
    __del__ = lambda self: None
RelinkableZeroInflationTermStructureHandle_swigregister = _QuantLib.RelinkableZeroInflationTermStructureHandle_swigregister
RelinkableZeroInflationTermStructureHandle_swigregister(RelinkableZeroInflationTermStructureHandle)

class Region(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def code(self):
        return _QuantLib.Region_code(self)
    __swig_destroy__ = _QuantLib.delete_Region
    __del__ = lambda self: None
Region_swigregister = _QuantLib.Region_swigregister
Region_swigregister(Region)

class CustomRegion(Region):
    thisown = _swig_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):
        this = _QuantLib.new_CustomRegion(name, code)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CustomRegion
    __del__ = lambda self: None
CustomRegion_swigregister = _QuantLib.CustomRegion_swigregister
CustomRegion_swigregister(CustomRegion)

class InflationIndex(Index):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def 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
    __del__ = lambda self: None
InflationIndex_swigregister = _QuantLib.InflationIndex_swigregister
InflationIndex_swigregister(InflationIndex)

class ZeroInflationIndex(InflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ZeroInflationIndex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroInflationIndex
    __del__ = lambda self: None
ZeroInflationIndex_swigregister = _QuantLib.ZeroInflationIndex_swigregister
ZeroInflationIndex_swigregister(ZeroInflationIndex)

class YoYInflationIndex(InflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_YoYInflationIndex
    __del__ = lambda self: None
YoYInflationIndex_swigregister = _QuantLib.YoYInflationIndex_swigregister
YoYInflationIndex_swigregister(YoYInflationIndex)

class EUHICP(ZeroInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EUHICP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EUHICP
    __del__ = lambda self: None
EUHICP_swigregister = _QuantLib.EUHICP_swigregister
EUHICP_swigregister(EUHICP)

class EUHICPXT(ZeroInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_EUHICPXT(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_EUHICPXT
    __del__ = lambda self: None
EUHICPXT_swigregister = _QuantLib.EUHICPXT_swigregister
EUHICPXT_swigregister(EUHICPXT)

class FRHICP(ZeroInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FRHICP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FRHICP
    __del__ = lambda self: None
FRHICP_swigregister = _QuantLib.FRHICP_swigregister
FRHICP_swigregister(FRHICP)

class UKRPI(ZeroInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_UKRPI(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_UKRPI
    __del__ = lambda self: None
UKRPI_swigregister = _QuantLib.UKRPI_swigregister
UKRPI_swigregister(UKRPI)

class USCPI(ZeroInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_USCPI(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_USCPI
    __del__ = lambda self: None
USCPI_swigregister = _QuantLib.USCPI_swigregister
USCPI_swigregister(USCPI)

class ZACPI(ZeroInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ZACPI(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZACPI
    __del__ = lambda self: None
ZACPI_swigregister = _QuantLib.ZACPI_swigregister
ZACPI_swigregister(ZACPI)

class YYEUHICP(YoYInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YYEUHICP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YYEUHICP
    __del__ = lambda self: None
YYEUHICP_swigregister = _QuantLib.YYEUHICP_swigregister
YYEUHICP_swigregister(YYEUHICP)

class YYEUHICPXT(YoYInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YYEUHICPXT(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YYEUHICPXT
    __del__ = lambda self: None
YYEUHICPXT_swigregister = _QuantLib.YYEUHICPXT_swigregister
YYEUHICPXT_swigregister(YYEUHICPXT)

class YYFRHICP(YoYInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YYFRHICP(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YYFRHICP
    __del__ = lambda self: None
YYFRHICP_swigregister = _QuantLib.YYFRHICP_swigregister
YYFRHICP_swigregister(YYFRHICP)

class YYUKRPI(YoYInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YYUKRPI(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YYUKRPI
    __del__ = lambda self: None
YYUKRPI_swigregister = _QuantLib.YYUKRPI_swigregister
YYUKRPI_swigregister(YYUKRPI)

class YYUSCPI(YoYInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YYUSCPI(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YYUSCPI
    __del__ = lambda self: None
YYUSCPI_swigregister = _QuantLib.YYUSCPI_swigregister
YYUSCPI_swigregister(YYUSCPI)

class YYZACPI(YoYInflationIndex):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_YYZACPI(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YYZACPI
    __del__ = lambda self: None
YYZACPI_swigregister = _QuantLib.YYZACPI_swigregister
YYZACPI_swigregister(YYZACPI)

class CPI(object):
    thisown = _swig_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):
        this = _QuantLib.new_CPI()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CPI
    __del__ = lambda self: None
CPI_swigregister = _QuantLib.CPI_swigregister
CPI_swigregister(CPI)

class ZeroHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_ZeroHelper()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroHelper
    __del__ = lambda self: None
ZeroHelper_swigregister = _QuantLib.ZeroHelper_swigregister
ZeroHelper_swigregister(ZeroHelper)

class YoYHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_YoYHelper()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YoYHelper
    __del__ = lambda self: None
YoYHelper_swigregister = _QuantLib.YoYHelper_swigregister
YoYHelper_swigregister(YoYHelper)

class ZeroHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_ZeroHelperVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
ZeroHelperVector_swigregister = _QuantLib.ZeroHelperVector_swigregister
ZeroHelperVector_swigregister(ZeroHelperVector)

class YoYHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.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):
        this = _QuantLib.new_YoYHelperVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
YoYHelperVector_swigregister = _QuantLib.YoYHelperVector_swigregister
YoYHelperVector_swigregister(YoYHelperVector)

class ZeroCouponInflationSwapHelper(ZeroHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rate, lag, maturity, calendar, bdc, dayCounter, index):
        this = _QuantLib.new_ZeroCouponInflationSwapHelper(rate, lag, maturity, calendar, bdc, dayCounter, index)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroCouponInflationSwapHelper
    __del__ = lambda self: None
ZeroCouponInflationSwapHelper_swigregister = _QuantLib.ZeroCouponInflationSwapHelper_swigregister
ZeroCouponInflationSwapHelper_swigregister(ZeroCouponInflationSwapHelper)

class YearOnYearInflationSwapHelper(YoYHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rate, lag, maturity, calendar, bdc, dayCounter, index):
        this = _QuantLib.new_YearOnYearInflationSwapHelper(rate, lag, maturity, calendar, bdc, dayCounter, index)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YearOnYearInflationSwapHelper
    __del__ = lambda self: None
YearOnYearInflationSwapHelper_swigregister = _QuantLib.YearOnYearInflationSwapHelper_swigregister
YearOnYearInflationSwapHelper_swigregister(YearOnYearInflationSwapHelper)

class PiecewiseZeroInflation(ZeroInflationTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_PiecewiseZeroInflation(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseZeroInflation_swigregister = _QuantLib.PiecewiseZeroInflation_swigregister
PiecewiseZeroInflation_swigregister(PiecewiseZeroInflation)

class PiecewiseYoYInflation(YoYInflationTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_PiecewiseYoYInflation(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseYoYInflation_swigregister = _QuantLib.PiecewiseYoYInflation_swigregister
PiecewiseYoYInflation_swigregister(PiecewiseYoYInflation)


def inflationBaseDate(referenceDate, observationLag, frequency, indexIsInterpolated):
    return _QuantLib.inflationBaseDate(referenceDate, observationLag, frequency, indexIsInterpolated)
inflationBaseDate = _QuantLib.inflationBaseDate
class ZeroCouponInflationSwap(Instrument):
    thisown = _swig_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):
        this = _QuantLib.new_ZeroCouponInflationSwap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fairRate(self):
        return _QuantLib.ZeroCouponInflationSwap_fairRate(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
    __del__ = lambda self: None
ZeroCouponInflationSwap_swigregister = _QuantLib.ZeroCouponInflationSwap_swigregister
ZeroCouponInflationSwap_swigregister(ZeroCouponInflationSwap)

class YearOnYearInflationSwap(Instrument):
    thisown = _swig_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):
        this = _QuantLib.new_YearOnYearInflationSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCounter, yoySchedule, index, lag, spread, yoyDayCounter, paymentCalendar, paymentConvention)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fairRate(self):
        return _QuantLib.YearOnYearInflationSwap_fairRate(self)
    __swig_destroy__ = _QuantLib.delete_YearOnYearInflationSwap
    __del__ = lambda self: None
YearOnYearInflationSwap_swigregister = _QuantLib.YearOnYearInflationSwap_swigregister
YearOnYearInflationSwap_swigregister(YearOnYearInflationSwap)

class YoYInflationCapFloor(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def impliedVolatility(self, 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 __init__(self):
        this = _QuantLib.new_YoYInflationCapFloor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YoYInflationCapFloor
    __del__ = lambda self: None
YoYInflationCapFloor_swigregister = _QuantLib.YoYInflationCapFloor_swigregister
YoYInflationCapFloor_swigregister(YoYInflationCapFloor)

class YoYInflationCap(YoYInflationCapFloor):
    thisown = _swig_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):
        this = _QuantLib.new_YoYInflationCap(leg, capRates)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YoYInflationCap
    __del__ = lambda self: None
YoYInflationCap_swigregister = _QuantLib.YoYInflationCap_swigregister
YoYInflationCap_swigregister(YoYInflationCap)

class YoYInflationFloor(YoYInflationCapFloor):
    thisown = _swig_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):
        this = _QuantLib.new_YoYInflationFloor(leg, floorRates)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YoYInflationFloor
    __del__ = lambda self: None
YoYInflationFloor_swigregister = _QuantLib.YoYInflationFloor_swigregister
YoYInflationFloor_swigregister(YoYInflationFloor)

class YoYInflationCollar(YoYInflationCapFloor):
    thisown = _swig_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):
        this = _QuantLib.new_YoYInflationCollar(leg, capRates, floorRates)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_YoYInflationCollar
    __del__ = lambda self: None
YoYInflationCollar_swigregister = _QuantLib.YoYInflationCollar_swigregister
YoYInflationCollar_swigregister(YoYInflationCollar)

class ShortRateModel(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.ShortRateModel_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_ShortRateModel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ShortRateModel
    __del__ = lambda self: None

    def params(self):
        return _QuantLib.ShortRateModel_params(self)

    def calibrate(self, *args):
        return _QuantLib.ShortRateModel_calibrate(self, *args)

    def value(self, params, arg3):
        return _QuantLib.ShortRateModel_value(self, params, arg3)

    def endCriteria(self):
        return _QuantLib.ShortRateModel_endCriteria(self)

    def setParams(self, params):
        return _QuantLib.ShortRateModel_setParams(self, params)
ShortRateModel_swigregister = _QuantLib.ShortRateModel_swigregister
ShortRateModel_swigregister(ShortRateModel)

class ShortRateModelHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ShortRateModelHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.ShortRateModelHandle___deref__(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
    __del__ = lambda self: None

    def params(self):
        return _QuantLib.ShortRateModelHandle_params(self)

    def calibrate(self, *args):
        return _QuantLib.ShortRateModelHandle_calibrate(self, *args)

    def value(self, params, arg3):
        return _QuantLib.ShortRateModelHandle_value(self, params, arg3)

    def endCriteria(self):
        return _QuantLib.ShortRateModelHandle_endCriteria(self)

    def setParams(self, params):
        return _QuantLib.ShortRateModelHandle_setParams(self, params)
ShortRateModelHandle_swigregister = _QuantLib.ShortRateModelHandle_swigregister
ShortRateModelHandle_swigregister(ShortRateModelHandle)

class RelinkableShortRateModelHandle(ShortRateModelHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableShortRateModelHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableShortRateModelHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableShortRateModelHandle
    __del__ = lambda self: None
RelinkableShortRateModelHandle_swigregister = _QuantLib.RelinkableShortRateModelHandle_swigregister
RelinkableShortRateModelHandle_swigregister(RelinkableShortRateModelHandle)

class Vasicek(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, r0=0.05, a=0.1, b=0.05, sigma=0.01, arg6=0.0):
        this = _QuantLib.new_Vasicek(r0, a, b, sigma, arg6)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def discount(self, t):
        return _QuantLib.Vasicek_discount(self, t)

    def discountBond(self, now, maturity, rate):
        return _QuantLib.Vasicek_discountBond(self, now, maturity, rate)
    __swig_destroy__ = _QuantLib.delete_Vasicek
    __del__ = lambda self: None
Vasicek_swigregister = _QuantLib.Vasicek_swigregister
Vasicek_swigregister(Vasicek)

class HullWhite(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, termStructure, a=0.1, sigma=0.01):
        this = _QuantLib.new_HullWhite(termStructure, a, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def discount(self, t):
        return _QuantLib.HullWhite_discount(self, t)

    def discountBond(self, now, maturity, rate):
        return _QuantLib.HullWhite_discountBond(self, now, maturity, rate)
    convexityBias = staticmethod(_QuantLib.HullWhite_convexityBias)
    __swig_destroy__ = _QuantLib.delete_HullWhite
    __del__ = lambda self: None
HullWhite_swigregister = _QuantLib.HullWhite_swigregister
HullWhite_swigregister(HullWhite)

def HullWhite_convexityBias(futurePrice, t, T, sigma, a):
    return _QuantLib.HullWhite_convexityBias(futurePrice, t, T, sigma, a)
HullWhite_convexityBias = _QuantLib.HullWhite_convexityBias

class BlackKarasinski(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, termStructure, a=0.1, sigma=0.1):
        this = _QuantLib.new_BlackKarasinski(termStructure, a, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackKarasinski
    __del__ = lambda self: None
BlackKarasinski_swigregister = _QuantLib.BlackKarasinski_swigregister
BlackKarasinski_swigregister(BlackKarasinski)

class G2(ShortRateModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, termStructure, a=0.1, sigma=0.01, b=0.1, eta=0.01, rho=-0.75):
        this = _QuantLib.new_G2(termStructure, a, sigma, b, eta, rho)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def discount(self, t):
        return _QuantLib.G2_discount(self, t)

    def discountBond(self, t, T, x, y):
        return _QuantLib.G2_discountBond(self, t, T, x, y)
    __swig_destroy__ = _QuantLib.delete_G2
    __del__ = lambda self: None
G2_swigregister = _QuantLib.G2_swigregister
G2_swigregister(G2)

class JamshidianSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_JamshidianSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_JamshidianSwaptionEngine
    __del__ = lambda self: None
JamshidianSwaptionEngine_swigregister = _QuantLib.JamshidianSwaptionEngine_swigregister
JamshidianSwaptionEngine_swigregister(JamshidianSwaptionEngine)

class TreeSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_TreeSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TreeSwaptionEngine
    __del__ = lambda self: None
TreeSwaptionEngine_swigregister = _QuantLib.TreeSwaptionEngine_swigregister
TreeSwaptionEngine_swigregister(TreeSwaptionEngine)

class AnalyticCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_AnalyticCapFloorEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_AnalyticCapFloorEngine
    __del__ = lambda self: None
AnalyticCapFloorEngine_swigregister = _QuantLib.AnalyticCapFloorEngine_swigregister
AnalyticCapFloorEngine_swigregister(AnalyticCapFloorEngine)

class TreeCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_TreeCapFloorEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TreeCapFloorEngine
    __del__ = lambda self: None
TreeCapFloorEngine_swigregister = _QuantLib.TreeCapFloorEngine_swigregister
TreeCapFloorEngine_swigregister(TreeCapFloorEngine)

class G2SwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, model, range, intervals):
        this = _QuantLib.new_G2SwaptionEngine(model, range, intervals)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_G2SwaptionEngine
    __del__ = lambda self: None
G2SwaptionEngine_swigregister = _QuantLib.G2SwaptionEngine_swigregister
G2SwaptionEngine_swigregister(G2SwaptionEngine)

class FdG2SwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FdG2SwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FdG2SwaptionEngine
    __del__ = lambda self: None
FdG2SwaptionEngine_swigregister = _QuantLib.FdG2SwaptionEngine_swigregister
FdG2SwaptionEngine_swigregister(FdG2SwaptionEngine)

class FdHullWhiteSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FdHullWhiteSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FdHullWhiteSwaptionEngine
    __del__ = lambda self: None
FdHullWhiteSwaptionEngine_swigregister = _QuantLib.FdHullWhiteSwaptionEngine_swigregister
FdHullWhiteSwaptionEngine_swigregister(FdHullWhiteSwaptionEngine)

class Bond(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Bond(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Bond_swigregister = _QuantLib.Bond_swigregister
Bond_swigregister(Bond)


def cleanPriceFromZSpread(*args):
    return _QuantLib.cleanPriceFromZSpread(*args)
cleanPriceFromZSpread = _QuantLib.cleanPriceFromZSpread
class ZeroCouponBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_ZeroCouponBond(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroCouponBond
    __del__ = lambda self: None
ZeroCouponBond_swigregister = _QuantLib.ZeroCouponBond_swigregister
ZeroCouponBond_swigregister(ZeroCouponBond)

class FixedRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FixedRateBond(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def frequency(self):
        return _QuantLib.FixedRateBond_frequency(self)

    def dayCounter(self):
        return _QuantLib.FixedRateBond_dayCounter(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBond
    __del__ = lambda self: None
FixedRateBond_swigregister = _QuantLib.FixedRateBond_swigregister
FixedRateBond_swigregister(FixedRateBond)

class FloatingRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_FloatingRateBond(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FloatingRateBond
    __del__ = lambda self: None
FloatingRateBond_swigregister = _QuantLib.FloatingRateBond_swigregister
FloatingRateBond_swigregister(FloatingRateBond)

class CmsRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_CmsRateBond(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CmsRateBond
    __del__ = lambda self: None
CmsRateBond_swigregister = _QuantLib.CmsRateBond_swigregister
CmsRateBond_swigregister(CmsRateBond)

class DiscountingBondEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, discountCurve):
        this = _QuantLib.new_DiscountingBondEngine(discountCurve)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DiscountingBondEngine
    __del__ = lambda self: None
DiscountingBondEngine_swigregister = _QuantLib.DiscountingBondEngine_swigregister
DiscountingBondEngine_swigregister(DiscountingBondEngine)

class CallableFixedRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, settlementDays, faceAmount, schedule, coupons, accrualDayCounter, paymentConvention, redemption, issueDate, putCallSchedule):
        this = _QuantLib.new_CallableFixedRateBond(settlementDays, faceAmount, schedule, coupons, accrualDayCounter, paymentConvention, redemption, issueDate, putCallSchedule)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def OAS(self, *args):
        return _QuantLib.CallableFixedRateBond_OAS(self, *args)

    def cleanPriceOAS(self, *args):
        return _QuantLib.CallableFixedRateBond_cleanPriceOAS(self, *args)

    def effectiveDuration(self, oas, engineTS, dayCounter, compounding, frequency, bump=2e-4):
        return _QuantLib.CallableFixedRateBond_effectiveDuration(self, oas, engineTS, dayCounter, compounding, frequency, bump)

    def effectiveConvexity(self, oas, engineTS, dayCounter, compounding, frequency, bump=2e-4):
        return _QuantLib.CallableFixedRateBond_effectiveConvexity(self, oas, engineTS, dayCounter, compounding, frequency, bump)
    __swig_destroy__ = _QuantLib.delete_CallableFixedRateBond
    __del__ = lambda self: None
CallableFixedRateBond_swigregister = _QuantLib.CallableFixedRateBond_swigregister
CallableFixedRateBond_swigregister(CallableFixedRateBond)

class TreeCallableFixedRateBondEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_TreeCallableFixedRateBondEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_TreeCallableFixedRateBondEngine
    __del__ = lambda self: None
TreeCallableFixedRateBondEngine_swigregister = _QuantLib.TreeCallableFixedRateBondEngine_swigregister
TreeCallableFixedRateBondEngine_swigregister(TreeCallableFixedRateBondEngine)

class BlackCallableFixedRateBondEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, fwdYieldVol, discountCurve):
        this = _QuantLib.new_BlackCallableFixedRateBondEngine(fwdYieldVol, discountCurve)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackCallableFixedRateBondEngine
    __del__ = lambda self: None
BlackCallableFixedRateBondEngine_swigregister = _QuantLib.BlackCallableFixedRateBondEngine_swigregister
BlackCallableFixedRateBondEngine_swigregister(BlackCallableFixedRateBondEngine)

class CPIBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_CPIBond(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CPIBond
    __del__ = lambda self: None
CPIBond_swigregister = _QuantLib.CPIBond_swigregister
CPIBond_swigregister(CPIBond)

class BondFunctions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    startDate = staticmethod(_QuantLib.BondFunctions_startDate)
    maturityDate = staticmethod(_QuantLib.BondFunctions_maturityDate)
    isTradable = staticmethod(_QuantLib.BondFunctions_isTradable)
    previousCashFlowDate = staticmethod(_QuantLib.BondFunctions_previousCashFlowDate)
    nextCashFlowDate = staticmethod(_QuantLib.BondFunctions_nextCashFlowDate)
    previousCashFlowAmount = staticmethod(_QuantLib.BondFunctions_previousCashFlowAmount)
    nextCashFlowAmount = staticmethod(_QuantLib.BondFunctions_nextCashFlowAmount)
    previousCouponRate = staticmethod(_QuantLib.BondFunctions_previousCouponRate)
    nextCouponRate = staticmethod(_QuantLib.BondFunctions_nextCouponRate)
    accrualStartDate = staticmethod(_QuantLib.BondFunctions_accrualStartDate)
    accrualEndDate = staticmethod(_QuantLib.BondFunctions_accrualEndDate)
    accrualPeriod = staticmethod(_QuantLib.BondFunctions_accrualPeriod)
    accrualDays = staticmethod(_QuantLib.BondFunctions_accrualDays)
    accruedPeriod = staticmethod(_QuantLib.BondFunctions_accruedPeriod)
    accruedDays = staticmethod(_QuantLib.BondFunctions_accruedDays)
    accruedAmount = staticmethod(_QuantLib.BondFunctions_accruedAmount)
    atmRate = staticmethod(_QuantLib.BondFunctions_atmRate)
    cleanPrice = staticmethod(_QuantLib.BondFunctions_cleanPrice)
    bps = staticmethod(_QuantLib.BondFunctions_bps)
    bondYield = staticmethod(_QuantLib.BondFunctions_bondYield)
    yieldBrent = staticmethod(_QuantLib.BondFunctions_yieldBrent)
    yieldBisection = staticmethod(_QuantLib.BondFunctions_yieldBisection)
    yieldFalsePosition = staticmethod(_QuantLib.BondFunctions_yieldFalsePosition)
    yieldRidder = staticmethod(_QuantLib.BondFunctions_yieldRidder)
    yieldSecant = staticmethod(_QuantLib.BondFunctions_yieldSecant)
    yieldNewton = staticmethod(_QuantLib.BondFunctions_yieldNewton)
    yieldNewtonSafe = staticmethod(_QuantLib.BondFunctions_yieldNewtonSafe)
    duration = staticmethod(_QuantLib.BondFunctions_duration)
    convexity = staticmethod(_QuantLib.BondFunctions_convexity)
    basisPointValue = staticmethod(_QuantLib.BondFunctions_basisPointValue)
    yieldValueBasisPoint = staticmethod(_QuantLib.BondFunctions_yieldValueBasisPoint)
    zSpread = staticmethod(_QuantLib.BondFunctions_zSpread)

    def __init__(self):
        this = _QuantLib.new_BondFunctions()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BondFunctions
    __del__ = lambda self: None
BondFunctions_swigregister = _QuantLib.BondFunctions_swigregister
BondFunctions_swigregister(BondFunctions)

def BondFunctions_startDate(bond):
    return _QuantLib.BondFunctions_startDate(bond)
BondFunctions_startDate = _QuantLib.BondFunctions_startDate

def BondFunctions_maturityDate(bond):
    return _QuantLib.BondFunctions_maturityDate(bond)
BondFunctions_maturityDate = _QuantLib.BondFunctions_maturityDate

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class CapFloor(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def impliedVolatility(self, 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)

    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 atmRate(self, discountCurve):
        return _QuantLib.CapFloor_atmRate(self, discountCurve)

    def __init__(self):
        this = _QuantLib.new_CapFloor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloor
    __del__ = lambda self: None
CapFloor_swigregister = _QuantLib.CapFloor_swigregister
CapFloor_swigregister(CapFloor)

class Cap(CapFloor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, leg, capRates):
        this = _QuantLib.new_Cap(leg, capRates)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Cap
    __del__ = lambda self: None
Cap_swigregister = _QuantLib.Cap_swigregister
Cap_swigregister(Cap)

class Floor(CapFloor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, leg, floorRates):
        this = _QuantLib.new_Floor(leg, floorRates)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Floor
    __del__ = lambda self: None
Floor_swigregister = _QuantLib.Floor_swigregister
Floor_swigregister(Floor)

class Collar(CapFloor):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, leg, capRates, floorRates):
        this = _QuantLib.new_Collar(leg, capRates, floorRates)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Collar
    __del__ = lambda self: None
Collar_swigregister = _QuantLib.Collar_swigregister
Collar_swigregister(Collar)

class BlackCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BlackCapFloorEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BlackCapFloorEngine
    __del__ = lambda self: None
BlackCapFloorEngine_swigregister = _QuantLib.BlackCapFloorEngine_swigregister
BlackCapFloorEngine_swigregister(BlackCapFloorEngine)

class BachelierCapFloorEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BachelierCapFloorEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BachelierCapFloorEngine
    __del__ = lambda self: None
BachelierCapFloorEngine_swigregister = _QuantLib.BachelierCapFloorEngine_swigregister
BachelierCapFloorEngine_swigregister(BachelierCapFloorEngine)

class Dividend(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_Dividend()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Dividend
    __del__ = lambda self: None

    def amount(self):
        return _QuantLib.Dividend_amount(self)

    def date(self):
        return _QuantLib.Dividend_date(self)
Dividend_swigregister = _QuantLib.Dividend_swigregister
Dividend_swigregister(Dividend)

class FixedDividend(Dividend):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, amount, date):
        this = _QuantLib.new_FixedDividend(amount, date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FixedDividend
    __del__ = lambda self: None
FixedDividend_swigregister = _QuantLib.FixedDividend_swigregister
FixedDividend_swigregister(FixedDividend)

class FractionalDividend(Dividend):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rate, date):
        this = _QuantLib.new_FractionalDividend(rate, date)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FractionalDividend
    __del__ = lambda self: None
FractionalDividend_swigregister = _QuantLib.FractionalDividend_swigregister
FractionalDividend_swigregister(FractionalDividend)

class DividendSchedule(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.DividendSchedule_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_DividendSchedule(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
DividendSchedule_swigregister = _QuantLib.DividendSchedule_swigregister
DividendSchedule_swigregister(DividendSchedule)

class ConvertibleZeroCouponBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, dayCounter, schedule, redemption=100.0):
        this = _QuantLib.new_ConvertibleZeroCouponBond(exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, dayCounter, schedule, redemption)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConvertibleZeroCouponBond
    __del__ = lambda self: None
ConvertibleZeroCouponBond_swigregister = _QuantLib.ConvertibleZeroCouponBond_swigregister
ConvertibleZeroCouponBond_swigregister(ConvertibleZeroCouponBond)

class ConvertibleFixedCouponBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, coupons, dayCounter, schedule, redemption=100.0):
        this = _QuantLib.new_ConvertibleFixedCouponBond(exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, coupons, dayCounter, schedule, redemption)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConvertibleFixedCouponBond
    __del__ = lambda self: None
ConvertibleFixedCouponBond_swigregister = _QuantLib.ConvertibleFixedCouponBond_swigregister
ConvertibleFixedCouponBond_swigregister(ConvertibleFixedCouponBond)

class ConvertibleFloatingRateBond(Bond):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, index, fixingDays, spreads, dayCounter, schedule, redemption=100.0):
        this = _QuantLib.new_ConvertibleFloatingRateBond(exercise, conversionRatio, dividends, callability, creditSpread, issueDate, settlementDays, index, fixingDays, spreads, dayCounter, schedule, redemption)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ConvertibleFloatingRateBond
    __del__ = lambda self: None
ConvertibleFloatingRateBond_swigregister = _QuantLib.ConvertibleFloatingRateBond_swigregister
ConvertibleFloatingRateBond_swigregister(ConvertibleFloatingRateBond)

class BinomialConvertibleEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, type, steps):
        this = _QuantLib.new_BinomialConvertibleEngine(process, type, steps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BinomialConvertibleEngine
    __del__ = lambda self: None
BinomialConvertibleEngine_swigregister = _QuantLib.BinomialConvertibleEngine_swigregister
BinomialConvertibleEngine_swigregister(BinomialConvertibleEngine)

class DefaultProbabilityTermStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.DefaultProbabilityTermStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_DefaultProbabilityTermStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityTermStructure
    __del__ = lambda self: None

    def dayCounter(self):
        return _QuantLib.DefaultProbabilityTermStructure_dayCounter(self)

    def calendar(self):
        return _QuantLib.DefaultProbabilityTermStructure_calendar(self)

    def referenceDate(self):
        return _QuantLib.DefaultProbabilityTermStructure_referenceDate(self)

    def maxDate(self):
        return _QuantLib.DefaultProbabilityTermStructure_maxDate(self)

    def maxTime(self):
        return _QuantLib.DefaultProbabilityTermStructure_maxTime(self)

    def defaultProbability(self, *args):
        return _QuantLib.DefaultProbabilityTermStructure_defaultProbability(self, *args)

    def survivalProbability(self, *args):
        return _QuantLib.DefaultProbabilityTermStructure_survivalProbability(self, *args)

    def defaultDensity(self, *args):
        return _QuantLib.DefaultProbabilityTermStructure_defaultDensity(self, *args)

    def hazardRate(self, *args):
        return _QuantLib.DefaultProbabilityTermStructure_hazardRate(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructure_allowsExtrapolation(self)
DefaultProbabilityTermStructure_swigregister = _QuantLib.DefaultProbabilityTermStructure_swigregister
DefaultProbabilityTermStructure_swigregister(DefaultProbabilityTermStructure)

class DefaultProbabilityTermStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DefaultProbabilityTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle___deref__(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
    __del__ = lambda self: None

    def dayCounter(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_dayCounter(self)

    def calendar(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_calendar(self)

    def referenceDate(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_referenceDate(self)

    def maxDate(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_maxDate(self)

    def maxTime(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_maxTime(self)

    def defaultProbability(self, *args):
        return _QuantLib.DefaultProbabilityTermStructureHandle_defaultProbability(self, *args)

    def survivalProbability(self, *args):
        return _QuantLib.DefaultProbabilityTermStructureHandle_survivalProbability(self, *args)

    def defaultDensity(self, *args):
        return _QuantLib.DefaultProbabilityTermStructureHandle_defaultDensity(self, *args)

    def hazardRate(self, *args):
        return _QuantLib.DefaultProbabilityTermStructureHandle_hazardRate(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.DefaultProbabilityTermStructureHandle_allowsExtrapolation(self)
DefaultProbabilityTermStructureHandle_swigregister = _QuantLib.DefaultProbabilityTermStructureHandle_swigregister
DefaultProbabilityTermStructureHandle_swigregister(DefaultProbabilityTermStructureHandle)

class RelinkableDefaultProbabilityTermStructureHandle(DefaultProbabilityTermStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableDefaultProbabilityTermStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableDefaultProbabilityTermStructureHandle
    __del__ = lambda self: None
RelinkableDefaultProbabilityTermStructureHandle_swigregister = _QuantLib.RelinkableDefaultProbabilityTermStructureHandle_swigregister
RelinkableDefaultProbabilityTermStructureHandle_swigregister(RelinkableDefaultProbabilityTermStructureHandle)

class FlatHazardRate(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FlatHazardRate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FlatHazardRate
    __del__ = lambda self: None
FlatHazardRate_swigregister = _QuantLib.FlatHazardRate_swigregister
FlatHazardRate_swigregister(FlatHazardRate)

class HazardRateCurve(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_HazardRateCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def hazardRates(self):
        return _QuantLib.HazardRateCurve_hazardRates(self)

    def nodes(self):
        return _QuantLib.HazardRateCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_HazardRateCurve
    __del__ = lambda self: None
HazardRateCurve_swigregister = _QuantLib.HazardRateCurve_swigregister
HazardRateCurve_swigregister(HazardRateCurve)

class DefaultDensityCurve(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DefaultDensityCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def defaultDensities(self):
        return _QuantLib.DefaultDensityCurve_defaultDensities(self)

    def nodes(self):
        return _QuantLib.DefaultDensityCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_DefaultDensityCurve
    __del__ = lambda self: None
DefaultDensityCurve_swigregister = _QuantLib.DefaultDensityCurve_swigregister
DefaultDensityCurve_swigregister(DefaultDensityCurve)

class DefaultProbabilityHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_DefaultProbabilityHelper()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultProbabilityHelper
    __del__ = lambda self: None
DefaultProbabilityHelper_swigregister = _QuantLib.DefaultProbabilityHelper_swigregister
DefaultProbabilityHelper_swigregister(DefaultProbabilityHelper)

class DefaultProbabilityHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.DefaultProbabilityHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_DefaultProbabilityHelperVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
DefaultProbabilityHelperVector_swigregister = _QuantLib.DefaultProbabilityHelperVector_swigregister
DefaultProbabilityHelperVector_swigregister(DefaultProbabilityHelperVector)

class SpreadCdsHelper(DefaultProbabilityHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SpreadCdsHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SpreadCdsHelper
    __del__ = lambda self: None
SpreadCdsHelper_swigregister = _QuantLib.SpreadCdsHelper_swigregister
SpreadCdsHelper_swigregister(SpreadCdsHelper)

class UpfrontCdsHelper(DefaultProbabilityHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_UpfrontCdsHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_UpfrontCdsHelper
    __del__ = lambda self: None
UpfrontCdsHelper_swigregister = _QuantLib.UpfrontCdsHelper_swigregister
UpfrontCdsHelper_swigregister(UpfrontCdsHelper)

class HazardRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_HazardRate()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_HazardRate
    __del__ = lambda self: None
HazardRate_swigregister = _QuantLib.HazardRate_swigregister
HazardRate_swigregister(HazardRate)

class DefaultDensity(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_DefaultDensity()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DefaultDensity
    __del__ = lambda self: None
DefaultDensity_swigregister = _QuantLib.DefaultDensity_swigregister
DefaultDensity_swigregister(DefaultDensity)

class PiecewiseFlatHazardRate(DefaultProbabilityTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseFlatHazardRate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def times(self):
        return _QuantLib.PiecewiseFlatHazardRate_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseFlatHazardRate_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseFlatHazardRate
    __del__ = lambda self: None
PiecewiseFlatHazardRate_swigregister = _QuantLib.PiecewiseFlatHazardRate_swigregister
PiecewiseFlatHazardRate_swigregister(PiecewiseFlatHazardRate)

class Protection(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Buyer = _QuantLib.Protection_Buyer
    Seller = _QuantLib.Protection_Seller

    def __init__(self):
        this = _QuantLib.new_Protection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Protection
    __del__ = lambda self: None
Protection_swigregister = _QuantLib.Protection_swigregister
Protection_swigregister(Protection)

class CreditDefaultSwap(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CreditDefaultSwap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def side(self):
        return _QuantLib.CreditDefaultSwap_side(self)

    def notional(self):
        return _QuantLib.CreditDefaultSwap_notional(self)

    def runningSpread(self):
        return _QuantLib.CreditDefaultSwap_runningSpread(self)

    def upfront(self):
        return _QuantLib.CreditDefaultSwap_upfront(self)

    def settlesAccrual(self):
        return _QuantLib.CreditDefaultSwap_settlesAccrual(self)

    def paysAtDefaultTime(self):
        return _QuantLib.CreditDefaultSwap_paysAtDefaultTime(self)

    def fairSpread(self):
        return _QuantLib.CreditDefaultSwap_fairSpread(self)

    def fairUpfront(self):
        return _QuantLib.CreditDefaultSwap_fairUpfront(self)

    def couponLegBPS(self):
        return _QuantLib.CreditDefaultSwap_couponLegBPS(self)

    def couponLegNPV(self):
        return _QuantLib.CreditDefaultSwap_couponLegNPV(self)

    def defaultLegNPV(self):
        return _QuantLib.CreditDefaultSwap_defaultLegNPV(self)

    def upfrontBPS(self):
        return _QuantLib.CreditDefaultSwap_upfrontBPS(self)

    def upfrontNPV(self):
        return _QuantLib.CreditDefaultSwap_upfrontNPV(self)

    def impliedHazardRate(self, targetNPV, discountCurve, dayCounter, recoveryRate=0.4, accuracy=1.0e-6):
        return _QuantLib.CreditDefaultSwap_impliedHazardRate(self, targetNPV, discountCurve, dayCounter, recoveryRate, accuracy)

    def coupons(self):
        return _QuantLib.CreditDefaultSwap_coupons(self)
    __swig_destroy__ = _QuantLib.delete_CreditDefaultSwap
    __del__ = lambda self: None
CreditDefaultSwap_swigregister = _QuantLib.CreditDefaultSwap_swigregister
CreditDefaultSwap_swigregister(CreditDefaultSwap)

class MidPointCdsEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, probability, recoveryRate, discountCurve):
        this = _QuantLib.new_MidPointCdsEngine(probability, recoveryRate, discountCurve)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MidPointCdsEngine
    __del__ = lambda self: None
MidPointCdsEngine_swigregister = _QuantLib.MidPointCdsEngine_swigregister
MidPointCdsEngine_swigregister(MidPointCdsEngine)

class IntegralCdsEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, integrationStep, probability, recoveryRate, discountCurve, includeSettlementDateFlows=False):
        this = _QuantLib.new_IntegralCdsEngine(integrationStep, probability, recoveryRate, discountCurve, includeSettlementDateFlows)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IntegralCdsEngine
    __del__ = lambda self: None
IntegralCdsEngine_swigregister = _QuantLib.IntegralCdsEngine_swigregister
IntegralCdsEngine_swigregister(IntegralCdsEngine)

class DiscountCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DiscountCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
DiscountCurve_swigregister = _QuantLib.DiscountCurve_swigregister
DiscountCurve_swigregister(DiscountCurve)

class NormalDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        this = _QuantLib.new_NormalDistribution(average, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
NormalDistribution_swigregister = _QuantLib.NormalDistribution_swigregister
NormalDistribution_swigregister(NormalDistribution)

class CumulativeNormalDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        this = _QuantLib.new_CumulativeNormalDistribution(average, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CumulativeNormalDistribution_swigregister = _QuantLib.CumulativeNormalDistribution_swigregister
CumulativeNormalDistribution_swigregister(CumulativeNormalDistribution)

class InverseCumulativeNormal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        this = _QuantLib.new_InverseCumulativeNormal(average, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.InverseCumulativeNormal___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeNormal
    __del__ = lambda self: None
InverseCumulativeNormal_swigregister = _QuantLib.InverseCumulativeNormal_swigregister
InverseCumulativeNormal_swigregister(InverseCumulativeNormal)

class MoroInverseCumulativeNormal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, average=0.0, sigma=1.0):
        this = _QuantLib.new_MoroInverseCumulativeNormal(average, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.MoroInverseCumulativeNormal___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_MoroInverseCumulativeNormal
    __del__ = lambda self: None
MoroInverseCumulativeNormal_swigregister = _QuantLib.MoroInverseCumulativeNormal_swigregister
MoroInverseCumulativeNormal_swigregister(MoroInverseCumulativeNormal)

class BivariateCumulativeNormalDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rho):
        this = _QuantLib.new_BivariateCumulativeNormalDistribution(rho)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, y):
        return _QuantLib.BivariateCumulativeNormalDistribution___call__(self, x, y)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistribution
    __del__ = lambda self: None
BivariateCumulativeNormalDistribution_swigregister = _QuantLib.BivariateCumulativeNormalDistribution_swigregister
BivariateCumulativeNormalDistribution_swigregister(BivariateCumulativeNormalDistribution)

class BinomialDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, p, n):
        this = _QuantLib.new_BinomialDistribution(p, n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, k):
        return _QuantLib.BinomialDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_BinomialDistribution
    __del__ = lambda self: None
BinomialDistribution_swigregister = _QuantLib.BinomialDistribution_swigregister
BinomialDistribution_swigregister(BinomialDistribution)

class CumulativeBinomialDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, p, n):
        this = _QuantLib.new_CumulativeBinomialDistribution(p, n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, k):
        return _QuantLib.CumulativeBinomialDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_CumulativeBinomialDistribution
    __del__ = lambda self: None
CumulativeBinomialDistribution_swigregister = _QuantLib.CumulativeBinomialDistribution_swigregister
CumulativeBinomialDistribution_swigregister(CumulativeBinomialDistribution)

class BivariateCumulativeNormalDistributionDr78(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rho):
        this = _QuantLib.new_BivariateCumulativeNormalDistributionDr78(rho)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, a, b):
        return _QuantLib.BivariateCumulativeNormalDistributionDr78___call__(self, a, b)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistributionDr78
    __del__ = lambda self: None
BivariateCumulativeNormalDistributionDr78_swigregister = _QuantLib.BivariateCumulativeNormalDistributionDr78_swigregister
BivariateCumulativeNormalDistributionDr78_swigregister(BivariateCumulativeNormalDistributionDr78)

class BivariateCumulativeNormalDistributionWe04DP(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rho):
        this = _QuantLib.new_BivariateCumulativeNormalDistributionWe04DP(rho)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, a, b):
        return _QuantLib.BivariateCumulativeNormalDistributionWe04DP___call__(self, a, b)
    __swig_destroy__ = _QuantLib.delete_BivariateCumulativeNormalDistributionWe04DP
    __del__ = lambda self: None
BivariateCumulativeNormalDistributionWe04DP_swigregister = _QuantLib.BivariateCumulativeNormalDistributionWe04DP_swigregister
BivariateCumulativeNormalDistributionWe04DP_swigregister(BivariateCumulativeNormalDistributionWe04DP)

class CumulativeChiSquareDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, df):
        this = _QuantLib.new_CumulativeChiSquareDistribution(df)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.CumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeChiSquareDistribution
    __del__ = lambda self: None
CumulativeChiSquareDistribution_swigregister = _QuantLib.CumulativeChiSquareDistribution_swigregister
CumulativeChiSquareDistribution_swigregister(CumulativeChiSquareDistribution)


def ChiSquareDistribution(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (ChiSquareDistribution.__name__, CumulativeChiSquareDistribution.__name__))
    return CumulativeChiSquareDistribution(*args, **kwargs)

class NonCentralCumulativeChiSquareDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, df, ncp):
        this = _QuantLib.new_NonCentralCumulativeChiSquareDistribution(df, ncp)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.NonCentralCumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_NonCentralCumulativeChiSquareDistribution
    __del__ = lambda self: None
NonCentralCumulativeChiSquareDistribution_swigregister = _QuantLib.NonCentralCumulativeChiSquareDistribution_swigregister
NonCentralCumulativeChiSquareDistribution_swigregister(NonCentralCumulativeChiSquareDistribution)


def NonCentralChiSquareDistribution(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (NonCentralChiSquareDistribution.__name__, NonCentralCumulativeChiSquareDistribution.__name__))
    return NonCentralCumulativeChiSquareDistribution(*args, **kwargs)

class InverseNonCentralCumulativeChiSquareDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, df, ncp, maxEvaluations=10, accuracy=1e-8):
        this = _QuantLib.new_InverseNonCentralCumulativeChiSquareDistribution(df, ncp, maxEvaluations, accuracy)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.InverseNonCentralCumulativeChiSquareDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseNonCentralCumulativeChiSquareDistribution
    __del__ = lambda self: None
InverseNonCentralCumulativeChiSquareDistribution_swigregister = _QuantLib.InverseNonCentralCumulativeChiSquareDistribution_swigregister
InverseNonCentralCumulativeChiSquareDistribution_swigregister(InverseNonCentralCumulativeChiSquareDistribution)


def InverseNonCentralChiSquareDistribution(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (InverseNonCentralChiSquareDistribution.__name__, InverseNonCentralCumulativeChiSquareDistribution.__name__))
    return InverseNonCentralCumulativeChiSquareDistribution(*args, **kwargs)

class CumulativeGammaDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, a):
        this = _QuantLib.new_CumulativeGammaDistribution(a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.CumulativeGammaDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeGammaDistribution
    __del__ = lambda self: None
CumulativeGammaDistribution_swigregister = _QuantLib.CumulativeGammaDistribution_swigregister
CumulativeGammaDistribution_swigregister(CumulativeGammaDistribution)


def GammaDistribution(*args, **kwargs):
    from warnings import warn
    warn('%s is deprecated; use %s' % (GammaDistribution.__name__, CumulativeGammaDistribution.__name__))
    return CumulativeGammaDistribution(*args, **kwargs)

class GammaFunction(object):
    thisown = _swig_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):
        this = _QuantLib.new_GammaFunction()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_GammaFunction
    __del__ = lambda self: None
GammaFunction_swigregister = _QuantLib.GammaFunction_swigregister
GammaFunction_swigregister(GammaFunction)

class PoissonDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, mu):
        this = _QuantLib.new_PoissonDistribution(mu)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, k):
        return _QuantLib.PoissonDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_PoissonDistribution
    __del__ = lambda self: None
PoissonDistribution_swigregister = _QuantLib.PoissonDistribution_swigregister
PoissonDistribution_swigregister(PoissonDistribution)

class CumulativePoissonDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, mu):
        this = _QuantLib.new_CumulativePoissonDistribution(mu)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, k):
        return _QuantLib.CumulativePoissonDistribution___call__(self, k)
    __swig_destroy__ = _QuantLib.delete_CumulativePoissonDistribution
    __del__ = lambda self: None
CumulativePoissonDistribution_swigregister = _QuantLib.CumulativePoissonDistribution_swigregister
CumulativePoissonDistribution_swigregister(CumulativePoissonDistribution)

class InverseCumulativePoisson(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, arg2):
        this = _QuantLib.new_InverseCumulativePoisson(arg2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.InverseCumulativePoisson___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativePoisson
    __del__ = lambda self: None
InverseCumulativePoisson_swigregister = _QuantLib.InverseCumulativePoisson_swigregister
InverseCumulativePoisson_swigregister(InverseCumulativePoisson)

class StudentDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n):
        this = _QuantLib.new_StudentDistribution(n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.StudentDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_StudentDistribution
    __del__ = lambda self: None
StudentDistribution_swigregister = _QuantLib.StudentDistribution_swigregister
StudentDistribution_swigregister(StudentDistribution)

class CumulativeStudentDistribution(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n):
        this = _QuantLib.new_CumulativeStudentDistribution(n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.CumulativeStudentDistribution___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_CumulativeStudentDistribution
    __del__ = lambda self: None
CumulativeStudentDistribution_swigregister = _QuantLib.CumulativeStudentDistribution_swigregister
CumulativeStudentDistribution_swigregister(CumulativeStudentDistribution)

class InverseCumulativeStudent(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, accuracy=1e-6, maxIterations=50):
        this = _QuantLib.new_InverseCumulativeStudent(n, accuracy, maxIterations)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x):
        return _QuantLib.InverseCumulativeStudent___call__(self, x)
    __swig_destroy__ = _QuantLib.delete_InverseCumulativeStudent
    __del__ = lambda self: None
InverseCumulativeStudent_swigregister = _QuantLib.InverseCumulativeStudent_swigregister
InverseCumulativeStudent_swigregister(InverseCumulativeStudent)

class Money(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Money(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def currency(self):
        return _QuantLib.Money_currency(self)

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

    def rounded(self):
        return _QuantLib.Money_rounded(self)

    def __pos__(self):
        return _QuantLib.Money___pos__(self)

    def __neg__(self):
        return _QuantLib.Money___neg__(self)

    def __add__(self, 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
    setConversionType = staticmethod(_QuantLib.Money_setConversionType)
    setBaseCurrency = staticmethod(_QuantLib.Money_setBaseCurrency)
    __swig_destroy__ = _QuantLib.delete_Money
    __del__ = lambda self: None
Money_swigregister = _QuantLib.Money_swigregister
Money_swigregister(Money)

def Money_setConversionType(type):
    return _QuantLib.Money_setConversionType(type)
Money_setConversionType = _QuantLib.Money_setConversionType

def Money_setBaseCurrency(c):
    return _QuantLib.Money_setBaseCurrency(c)
Money_setBaseCurrency = _QuantLib.Money_setBaseCurrency

class ExchangeRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Direct = _QuantLib.ExchangeRate_Direct
    Derived = _QuantLib.ExchangeRate_Derived

    def __init__(self, source, target, rate):
        this = _QuantLib.new_ExchangeRate(source, target, rate)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def source(self):
        return _QuantLib.ExchangeRate_source(self)

    def target(self):
        return _QuantLib.ExchangeRate_target(self)

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

    def rate(self):
        return _QuantLib.ExchangeRate_rate(self)

    def exchange(self, amount):
        return _QuantLib.ExchangeRate_exchange(self, amount)
    chain = staticmethod(_QuantLib.ExchangeRate_chain)
    __swig_destroy__ = _QuantLib.delete_ExchangeRate
    __del__ = lambda self: None
ExchangeRate_swigregister = _QuantLib.ExchangeRate_swigregister
ExchangeRate_swigregister(ExchangeRate)

def ExchangeRate_chain(r1, r2):
    return _QuantLib.ExchangeRate_chain(r1, r2)
ExchangeRate_chain = _QuantLib.ExchangeRate_chain

class ExchangeRateManager(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    instance = staticmethod(_QuantLib.ExchangeRateManager_instance)

    def add(self, *args):
        return _QuantLib.ExchangeRateManager_add(self, *args)

    def lookup(self, *args):
        return _QuantLib.ExchangeRateManager_lookup(self, *args)

    def clear(self):
        return _QuantLib.ExchangeRateManager_clear(self)
    __swig_destroy__ = _QuantLib.delete_ExchangeRateManager
    __del__ = lambda self: None
ExchangeRateManager_swigregister = _QuantLib.ExchangeRateManager_swigregister
ExchangeRateManager_swigregister(ExchangeRateManager)

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

class Futures(object):
    thisown = _swig_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):
        this = _QuantLib.new_Futures()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Futures
    __del__ = lambda self: None
Futures_swigregister = _QuantLib.Futures_swigregister
Futures_swigregister(Futures)

class TimeBasket(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_TimeBasket(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
TimeBasket_swigregister = _QuantLib.TimeBasket_swigregister
TimeBasket_swigregister(TimeBasket)

class Swap(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, firstLeg, secondLeg):
        this = _QuantLib.new_Swap(firstLeg, secondLeg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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)
    __swig_destroy__ = _QuantLib.delete_Swap
    __del__ = lambda self: None
Swap_swigregister = _QuantLib.Swap_swigregister
Swap_swigregister(Swap)

class VanillaSwap(Swap):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Receiver = _QuantLib.VanillaSwap_Receiver
    Payer = _QuantLib.VanillaSwap_Payer

    def __init__(self, type, nominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, spread, floatingDayCount):
        this = _QuantLib.new_VanillaSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, spread, floatingDayCount)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fairRate(self):
        return _QuantLib.VanillaSwap_fairRate(self)

    def fairSpread(self):
        return _QuantLib.VanillaSwap_fairSpread(self)

    def fixedLegBPS(self):
        return _QuantLib.VanillaSwap_fixedLegBPS(self)

    def floatingLegBPS(self):
        return _QuantLib.VanillaSwap_floatingLegBPS(self)

    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
    __del__ = lambda self: None
VanillaSwap_swigregister = _QuantLib.VanillaSwap_swigregister
VanillaSwap_swigregister(VanillaSwap)

class NonstandardSwap(Swap):
    thisown = _swig_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):
        this = _QuantLib.new_NonstandardSwap(type, fixedNominal, floatingNominal, fixedSchedule, fixedRate, fixedDayCount, floatSchedule, index, gearing, spread, floatDayCount, intermediateCapitalExchange, finalCapitalExchange, paymentConvention)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fixedLeg(self):
        return _QuantLib.NonstandardSwap_fixedLeg(self)

    def floatingLeg(self):
        return _QuantLib.NonstandardSwap_floatingLeg(self)

    def fixedNominals(self):
        return _QuantLib.NonstandardSwap_fixedNominals(self)

    def floatingNominals(self):
        return _QuantLib.NonstandardSwap_floatingNominals(self)

    def fixedSchedule(self):
        return _QuantLib.NonstandardSwap_fixedSchedule(self)

    def floatingSchedule(self):
        return _QuantLib.NonstandardSwap_floatingSchedule(self)

    def fixedRate(self):
        return _QuantLib.NonstandardSwap_fixedRate(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 fixedDayCount(self):
        return _QuantLib.NonstandardSwap_fixedDayCount(self)
    __swig_destroy__ = _QuantLib.delete_NonstandardSwap
    __del__ = lambda self: None
NonstandardSwap_swigregister = _QuantLib.NonstandardSwap_swigregister
NonstandardSwap_swigregister(NonstandardSwap)

class DiscountingSwapEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DiscountingSwapEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DiscountingSwapEngine
    __del__ = lambda self: None
DiscountingSwapEngine_swigregister = _QuantLib.DiscountingSwapEngine_swigregister
DiscountingSwapEngine_swigregister(DiscountingSwapEngine)

class AssetSwap(Swap):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_AssetSwap(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fairCleanPrice(self):
        return _QuantLib.AssetSwap_fairCleanPrice(self)

    def fairSpread(self):
        return _QuantLib.AssetSwap_fairSpread(self)
    __swig_destroy__ = _QuantLib.delete_AssetSwap
    __del__ = lambda self: None
AssetSwap_swigregister = _QuantLib.AssetSwap_swigregister
AssetSwap_swigregister(AssetSwap)

class FloatFloatSwap(Swap):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FloatFloatSwap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FloatFloatSwap
    __del__ = lambda self: None
FloatFloatSwap_swigregister = _QuantLib.FloatFloatSwap_swigregister
FloatFloatSwap_swigregister(FloatFloatSwap)

class Pillar(object):
    thisown = _swig_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):
        this = _QuantLib.new_Pillar()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Pillar
    __del__ = lambda self: None
Pillar_swigregister = _QuantLib.Pillar_swigregister
Pillar_swigregister(Pillar)

class RateHelper(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_RateHelper()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_RateHelper
    __del__ = lambda self: None

    def quote(self):
        return _QuantLib.RateHelper_quote(self)

    def latestDate(self):
        return _QuantLib.RateHelper_latestDate(self)
RateHelper_swigregister = _QuantLib.RateHelper_swigregister
RateHelper_swigregister(RateHelper)

class DepositRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DepositRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DepositRateHelper
    __del__ = lambda self: None
DepositRateHelper_swigregister = _QuantLib.DepositRateHelper_swigregister
DepositRateHelper_swigregister(DepositRateHelper)

class FraRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FraRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FraRateHelper
    __del__ = lambda self: None
FraRateHelper_swigregister = _QuantLib.FraRateHelper_swigregister
FraRateHelper_swigregister(FraRateHelper)

class FuturesRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FuturesRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FuturesRateHelper
    __del__ = lambda self: None
FuturesRateHelper_swigregister = _QuantLib.FuturesRateHelper_swigregister
FuturesRateHelper_swigregister(FuturesRateHelper)

class SwapRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SwapRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def swap(self):
        return _QuantLib.SwapRateHelper_swap(self)
    __swig_destroy__ = _QuantLib.delete_SwapRateHelper
    __del__ = lambda self: None
SwapRateHelper_swigregister = _QuantLib.SwapRateHelper_swigregister
SwapRateHelper_swigregister(SwapRateHelper)

class BondHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, cleanPrice, bond, useCleanPrice=True):
        this = _QuantLib.new_BondHelper(cleanPrice, bond, useCleanPrice)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def bond(self):
        return _QuantLib.BondHelper_bond(self)
    __swig_destroy__ = _QuantLib.delete_BondHelper
    __del__ = lambda self: None
BondHelper_swigregister = _QuantLib.BondHelper_swigregister
BondHelper_swigregister(BondHelper)

class FixedRateBondHelper(BondHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FixedRateBondHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def bond(self):
        return _QuantLib.FixedRateBondHelper_bond(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBondHelper
    __del__ = lambda self: None
FixedRateBondHelper_swigregister = _QuantLib.FixedRateBondHelper_swigregister
FixedRateBondHelper_swigregister(FixedRateBondHelper)

class OISRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_OISRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_OISRateHelper
    __del__ = lambda self: None
OISRateHelper_swigregister = _QuantLib.OISRateHelper_swigregister
OISRateHelper_swigregister(OISRateHelper)

class DatedOISRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_DatedOISRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DatedOISRateHelper
    __del__ = lambda self: None
DatedOISRateHelper_swigregister = _QuantLib.DatedOISRateHelper_swigregister
DatedOISRateHelper_swigregister(DatedOISRateHelper)

class FxSwapRateHelper(RateHelper):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FxSwapRateHelper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_FxSwapRateHelper
    __del__ = lambda self: None
FxSwapRateHelper_swigregister = _QuantLib.FxSwapRateHelper_swigregister
FxSwapRateHelper_swigregister(FxSwapRateHelper)

class RateHelperVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _QuantLib.RateHelperVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __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):
        this = _QuantLib.new_RateHelperVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
RateHelperVector_swigregister = _QuantLib.RateHelperVector_swigregister
RateHelperVector_swigregister(RateHelperVector)

class FittingMethod(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _QuantLib.delete_FittingMethod
    __del__ = lambda self: None

    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)
FittingMethod_swigregister = _QuantLib.FittingMethod_swigregister
FittingMethod_swigregister(FittingMethod)

class FittedBondDiscountCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FittedBondDiscountCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fitResults(self):
        return _QuantLib.FittedBondDiscountCurve_fitResults(self)
    __swig_destroy__ = _QuantLib.delete_FittedBondDiscountCurve
    __del__ = lambda self: None
FittedBondDiscountCurve_swigregister = _QuantLib.FittedBondDiscountCurve_swigregister
FittedBondDiscountCurve_swigregister(FittedBondDiscountCurve)

class ExponentialSplinesFitting(FittingMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ExponentialSplinesFitting(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ExponentialSplinesFitting
    __del__ = lambda self: None
ExponentialSplinesFitting_swigregister = _QuantLib.ExponentialSplinesFitting_swigregister
ExponentialSplinesFitting_swigregister(ExponentialSplinesFitting)

class NelsonSiegelFitting(FittingMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_NelsonSiegelFitting(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NelsonSiegelFitting
    __del__ = lambda self: None
NelsonSiegelFitting_swigregister = _QuantLib.NelsonSiegelFitting_swigregister
NelsonSiegelFitting_swigregister(NelsonSiegelFitting)

class SvenssonFitting(FittingMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SvenssonFitting(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SvenssonFitting
    __del__ = lambda self: None
SvenssonFitting_swigregister = _QuantLib.SvenssonFitting_swigregister
SvenssonFitting_swigregister(SvenssonFitting)

class CubicBSplinesFitting(FittingMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CubicBSplinesFitting(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def basisFunction(self, i, t):
        return _QuantLib.CubicBSplinesFitting_basisFunction(self, i, t)
    __swig_destroy__ = _QuantLib.delete_CubicBSplinesFitting
    __del__ = lambda self: None
CubicBSplinesFitting_swigregister = _QuantLib.CubicBSplinesFitting_swigregister
CubicBSplinesFitting_swigregister(CubicBSplinesFitting)

class SimplePolynomialFitting(FittingMethod):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SimplePolynomialFitting(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_SimplePolynomialFitting
    __del__ = lambda self: None
SimplePolynomialFitting_swigregister = _QuantLib.SimplePolynomialFitting_swigregister
SimplePolynomialFitting_swigregister(SimplePolynomialFitting)

class ForwardCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ForwardCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def forwards(self):
        return _QuantLib.ForwardCurve_forwards(self)

    def nodes(self):
        return _QuantLib.ForwardCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ForwardCurve
    __del__ = lambda self: None
ForwardCurve_swigregister = _QuantLib.ForwardCurve_swigregister
ForwardCurve_swigregister(ForwardCurve)

class Position(object):
    thisown = _swig_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):
        this = _QuantLib.new_Position()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Position
    __del__ = lambda self: None
Position_swigregister = _QuantLib.Position_swigregister
Position_swigregister(Position)

class ForwardRateAgreement(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ForwardRateAgreement(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
ForwardRateAgreement_swigregister = _QuantLib.ForwardRateAgreement_swigregister
ForwardRateAgreement_swigregister(ForwardRateAgreement)

class Gaussian1dModel(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_Gaussian1dModel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Gaussian1dModel
    __del__ = lambda self: None

    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)
Gaussian1dModel_swigregister = _QuantLib.Gaussian1dModel_swigregister
Gaussian1dModel_swigregister(Gaussian1dModel)

class Gsr(Gaussian1dModel):
    thisown = _swig_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):
        this = _QuantLib.new_Gsr(termStructure, volstepdates, volatilities, reversions, T)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calibrateVolatilitiesIterative(self, *args):
        return _QuantLib.Gsr_calibrateVolatilitiesIterative(self, *args)

    def calibrate(self, *args):
        return _QuantLib.Gsr_calibrate(self, *args)

    def params(self):
        return _QuantLib.Gsr_params(self)

    def value(self, params, helpers):
        return _QuantLib.Gsr_value(self, params, helpers)

    def endCriteria(self):
        return _QuantLib.Gsr_endCriteria(self)

    def setParams(self, params):
        return _QuantLib.Gsr_setParams(self, params)

    def functionEvaluation(self):
        return _QuantLib.Gsr_functionEvaluation(self)

    def reversion(self):
        return _QuantLib.Gsr_reversion(self)

    def volatility(self):
        return _QuantLib.Gsr_volatility(self)
    __swig_destroy__ = _QuantLib.delete_Gsr
    __del__ = lambda self: None
Gsr_swigregister = _QuantLib.Gsr_swigregister
Gsr_swigregister(Gsr)

class MarkovFunctionalSettings(object):
    thisown = _swig_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):
        this = _QuantLib.new_MarkovFunctionalSettings()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_MarkovFunctionalSettings
    __del__ = lambda self: None
MarkovFunctionalSettings_swigregister = _QuantLib.MarkovFunctionalSettings_swigregister
MarkovFunctionalSettings_swigregister(MarkovFunctionalSettings)

class MarkovFunctional(Gaussian1dModel):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    AdjustNone = _QuantLib.MarkovFunctional_AdjustNone
    AdjustDigitals = _QuantLib.MarkovFunctional_AdjustDigitals
    AdjustYts = _QuantLib.MarkovFunctional_AdjustYts
    ExtrapolatePayoffFlat = _QuantLib.MarkovFunctional_ExtrapolatePayoffFlat
    NoPayoffExtrapolation = _QuantLib.MarkovFunctional_NoPayoffExtrapolation
    KahaleSmile = _QuantLib.MarkovFunctional_KahaleSmile
    SmileExponentialExtrapolation = _QuantLib.MarkovFunctional_SmileExponentialExtrapolation
    KahaleInterpolation = _QuantLib.MarkovFunctional_KahaleInterpolation
    SmileDeleteArbitragePoints = _QuantLib.MarkovFunctional_SmileDeleteArbitragePoints
    SabrSmile = _QuantLib.MarkovFunctional_SabrSmile

    def __init__(self, *args):
        this = _QuantLib.new_MarkovFunctional(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calibrate(self, *args):
        return _QuantLib.MarkovFunctional_calibrate(self, *args)

    def volatility(self):
        return _QuantLib.MarkovFunctional_volatility(self)
    __swig_destroy__ = _QuantLib.delete_MarkovFunctional
    __del__ = lambda self: None
MarkovFunctional_swigregister = _QuantLib.MarkovFunctional_swigregister
MarkovFunctional_swigregister(MarkovFunctional)

class Gaussian1dSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Gaussian1dSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Gaussian1dSwaptionEngine
    __del__ = lambda self: None
Gaussian1dSwaptionEngine_swigregister = _QuantLib.Gaussian1dSwaptionEngine_swigregister
Gaussian1dSwaptionEngine_swigregister(Gaussian1dSwaptionEngine)

class Gaussian1dJamshidianSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, model):
        this = _QuantLib.new_Gaussian1dJamshidianSwaptionEngine(model)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Gaussian1dJamshidianSwaptionEngine
    __del__ = lambda self: None
Gaussian1dJamshidianSwaptionEngine_swigregister = _QuantLib.Gaussian1dJamshidianSwaptionEngine_swigregister
Gaussian1dJamshidianSwaptionEngine_swigregister(Gaussian1dJamshidianSwaptionEngine)

class Gaussian1dNonstandardSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Gaussian1dNonstandardSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Gaussian1dNonstandardSwaptionEngine
    __del__ = lambda self: None
Gaussian1dNonstandardSwaptionEngine_swigregister = _QuantLib.Gaussian1dNonstandardSwaptionEngine_swigregister
Gaussian1dNonstandardSwaptionEngine_swigregister(Gaussian1dNonstandardSwaptionEngine)

class Gaussian1dFloatFloatSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    _None = _QuantLib.Gaussian1dFloatFloatSwaptionEngine__None
    Naive = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_Naive
    Digital = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_Digital

    def __init__(self, *args):
        this = _QuantLib.new_Gaussian1dFloatFloatSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Gaussian1dFloatFloatSwaptionEngine
    __del__ = lambda self: None
Gaussian1dFloatFloatSwaptionEngine_swigregister = _QuantLib.Gaussian1dFloatFloatSwaptionEngine_swigregister
Gaussian1dFloatFloatSwaptionEngine_swigregister(Gaussian1dFloatFloatSwaptionEngine)

class SegmentIntegral(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, intervals):
        this = _QuantLib.new_SegmentIntegral(intervals)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.SegmentIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_SegmentIntegral
    __del__ = lambda self: None
SegmentIntegral_swigregister = _QuantLib.SegmentIntegral_swigregister
SegmentIntegral_swigregister(SegmentIntegral)

class TrapezoidIntegralDefault(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        this = _QuantLib.new_TrapezoidIntegralDefault(accuracy, maxIterations)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.TrapezoidIntegralDefault___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralDefault
    __del__ = lambda self: None
TrapezoidIntegralDefault_swigregister = _QuantLib.TrapezoidIntegralDefault_swigregister
TrapezoidIntegralDefault_swigregister(TrapezoidIntegralDefault)

class TrapezoidIntegralMidPoint(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        this = _QuantLib.new_TrapezoidIntegralMidPoint(accuracy, maxIterations)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.TrapezoidIntegralMidPoint___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_TrapezoidIntegralMidPoint
    __del__ = lambda self: None
TrapezoidIntegralMidPoint_swigregister = _QuantLib.TrapezoidIntegralMidPoint_swigregister
TrapezoidIntegralMidPoint_swigregister(TrapezoidIntegralMidPoint)

class SimpsonIntegral(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, accuracy, maxIterations):
        this = _QuantLib.new_SimpsonIntegral(accuracy, maxIterations)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.SimpsonIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_SimpsonIntegral
    __del__ = lambda self: None
SimpsonIntegral_swigregister = _QuantLib.SimpsonIntegral_swigregister
SimpsonIntegral_swigregister(SimpsonIntegral)

class GaussKronrodAdaptive(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_GaussKronrodAdaptive(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.GaussKronrodAdaptive___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodAdaptive
    __del__ = lambda self: None
GaussKronrodAdaptive_swigregister = _QuantLib.GaussKronrodAdaptive_swigregister
GaussKronrodAdaptive_swigregister(GaussKronrodAdaptive)

class GaussKronrodNonAdaptive(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, absoluteAccuracy, maxEvaluations, relativeAccuracy):
        this = _QuantLib.new_GaussKronrodNonAdaptive(absoluteAccuracy, maxEvaluations, relativeAccuracy)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.GaussKronrodNonAdaptive___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussKronrodNonAdaptive
    __del__ = lambda self: None
GaussKronrodNonAdaptive_swigregister = _QuantLib.GaussKronrodNonAdaptive_swigregister
GaussKronrodNonAdaptive_swigregister(GaussKronrodNonAdaptive)

class GaussLobattoIntegral(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_GaussLobattoIntegral(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction, a, b):
        return _QuantLib.GaussLobattoIntegral___call__(self, pyFunction, a, b)
    __swig_destroy__ = _QuantLib.delete_GaussLobattoIntegral
    __del__ = lambda self: None
GaussLobattoIntegral_swigregister = _QuantLib.GaussLobattoIntegral_swigregister
GaussLobattoIntegral_swigregister(GaussLobattoIntegral)

class GaussLaguerreIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, s=0.0):
        this = _QuantLib.new_GaussLaguerreIntegration(n, s)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussLaguerreIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussLaguerreIntegration
    __del__ = lambda self: None
GaussLaguerreIntegration_swigregister = _QuantLib.GaussLaguerreIntegration_swigregister
GaussLaguerreIntegration_swigregister(GaussLaguerreIntegration)

class GaussHermiteIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, mu=0.0):
        this = _QuantLib.new_GaussHermiteIntegration(n, mu)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussHermiteIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussHermiteIntegration
    __del__ = lambda self: None
GaussHermiteIntegration_swigregister = _QuantLib.GaussHermiteIntegration_swigregister
GaussHermiteIntegration_swigregister(GaussHermiteIntegration)

class GaussJacobiIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, alpha, beta):
        this = _QuantLib.new_GaussJacobiIntegration(n, alpha, beta)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussJacobiIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussJacobiIntegration
    __del__ = lambda self: None
GaussJacobiIntegration_swigregister = _QuantLib.GaussJacobiIntegration_swigregister
GaussJacobiIntegration_swigregister(GaussJacobiIntegration)

class GaussHyperbolicIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n):
        this = _QuantLib.new_GaussHyperbolicIntegration(n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussHyperbolicIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussHyperbolicIntegration
    __del__ = lambda self: None
GaussHyperbolicIntegration_swigregister = _QuantLib.GaussHyperbolicIntegration_swigregister
GaussHyperbolicIntegration_swigregister(GaussHyperbolicIntegration)

class GaussLegendreIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n):
        this = _QuantLib.new_GaussLegendreIntegration(n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussLegendreIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussLegendreIntegration
    __del__ = lambda self: None
GaussLegendreIntegration_swigregister = _QuantLib.GaussLegendreIntegration_swigregister
GaussLegendreIntegration_swigregister(GaussLegendreIntegration)

class GaussChebyshevIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n):
        this = _QuantLib.new_GaussChebyshevIntegration(n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussChebyshevIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussChebyshevIntegration
    __del__ = lambda self: None
GaussChebyshevIntegration_swigregister = _QuantLib.GaussChebyshevIntegration_swigregister
GaussChebyshevIntegration_swigregister(GaussChebyshevIntegration)

class GaussChebyshev2ndIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n):
        this = _QuantLib.new_GaussChebyshev2ndIntegration(n)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussChebyshev2ndIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussChebyshev2ndIntegration
    __del__ = lambda self: None
GaussChebyshev2ndIntegration_swigregister = _QuantLib.GaussChebyshev2ndIntegration_swigregister
GaussChebyshev2ndIntegration_swigregister(GaussChebyshev2ndIntegration)

class GaussGegenbauerIntegration(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, arg3):
        this = _QuantLib.new_GaussGegenbauerIntegration(n, arg3)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, pyFunction):
        return _QuantLib.GaussGegenbauerIntegration___call__(self, pyFunction)
    __swig_destroy__ = _QuantLib.delete_GaussGegenbauerIntegration
    __del__ = lambda self: None
GaussGegenbauerIntegration_swigregister = _QuantLib.GaussGegenbauerIntegration_swigregister
GaussGegenbauerIntegration_swigregister(GaussGegenbauerIntegration)

class SampleNumber(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def weight(self):
        return _QuantLib.SampleNumber_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleNumber
    __del__ = lambda self: None
SampleNumber_swigregister = _QuantLib.SampleNumber_swigregister
SampleNumber_swigregister(SampleNumber)

class SampleArray(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def weight(self):
        return _QuantLib.SampleArray_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleArray
    __del__ = lambda self: None
SampleArray_swigregister = _QuantLib.SampleArray_swigregister
SampleArray_swigregister(SampleArray)

class SampleRealVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def weight(self):
        return _QuantLib.SampleRealVector_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleRealVector
    __del__ = lambda self: None
SampleRealVector_swigregister = _QuantLib.SampleRealVector_swigregister
SampleRealVector_swigregister(SampleRealVector)

class LecuyerUniformRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_LecuyerUniformRng(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.LecuyerUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRng
    __del__ = lambda self: None
LecuyerUniformRng_swigregister = _QuantLib.LecuyerUniformRng_swigregister
LecuyerUniformRng_swigregister(LecuyerUniformRng)

class KnuthUniformRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_KnuthUniformRng(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.KnuthUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRng
    __del__ = lambda self: None
KnuthUniformRng_swigregister = _QuantLib.KnuthUniformRng_swigregister
KnuthUniformRng_swigregister(KnuthUniformRng)

class MersenneTwisterUniformRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_MersenneTwisterUniformRng(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.MersenneTwisterUniformRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRng
    __del__ = lambda self: None
MersenneTwisterUniformRng_swigregister = _QuantLib.MersenneTwisterUniformRng_swigregister
MersenneTwisterUniformRng_swigregister(MersenneTwisterUniformRng)

class UniformRandomGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, seed=0):
        this = _QuantLib.new_UniformRandomGenerator(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.UniformRandomGenerator_next(self)

    def nextValue(self):
        return _QuantLib.UniformRandomGenerator_nextValue(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomGenerator
    __del__ = lambda self: None
UniformRandomGenerator_swigregister = _QuantLib.UniformRandomGenerator_swigregister
UniformRandomGenerator_swigregister(UniformRandomGenerator)

class CentralLimitLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_CentralLimitLecuyerGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.CentralLimitLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitLecuyerGaussianRng
    __del__ = lambda self: None
CentralLimitLecuyerGaussianRng_swigregister = _QuantLib.CentralLimitLecuyerGaussianRng_swigregister
CentralLimitLecuyerGaussianRng_swigregister(CentralLimitLecuyerGaussianRng)

class CentralLimitKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_CentralLimitKnuthGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.CentralLimitKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitKnuthGaussianRng
    __del__ = lambda self: None
CentralLimitKnuthGaussianRng_swigregister = _QuantLib.CentralLimitKnuthGaussianRng_swigregister
CentralLimitKnuthGaussianRng_swigregister(CentralLimitKnuthGaussianRng)

class CentralLimitMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_CentralLimitMersenneTwisterGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.CentralLimitMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_CentralLimitMersenneTwisterGaussianRng
    __del__ = lambda self: None
CentralLimitMersenneTwisterGaussianRng_swigregister = _QuantLib.CentralLimitMersenneTwisterGaussianRng_swigregister
CentralLimitMersenneTwisterGaussianRng_swigregister(CentralLimitMersenneTwisterGaussianRng)

class BoxMullerLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_BoxMullerLecuyerGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.BoxMullerLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerLecuyerGaussianRng
    __del__ = lambda self: None
BoxMullerLecuyerGaussianRng_swigregister = _QuantLib.BoxMullerLecuyerGaussianRng_swigregister
BoxMullerLecuyerGaussianRng_swigregister(BoxMullerLecuyerGaussianRng)

class BoxMullerKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_BoxMullerKnuthGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.BoxMullerKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerKnuthGaussianRng
    __del__ = lambda self: None
BoxMullerKnuthGaussianRng_swigregister = _QuantLib.BoxMullerKnuthGaussianRng_swigregister
BoxMullerKnuthGaussianRng_swigregister(BoxMullerKnuthGaussianRng)

class BoxMullerMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_BoxMullerMersenneTwisterGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.BoxMullerMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_BoxMullerMersenneTwisterGaussianRng
    __del__ = lambda self: None
BoxMullerMersenneTwisterGaussianRng_swigregister = _QuantLib.BoxMullerMersenneTwisterGaussianRng_swigregister
BoxMullerMersenneTwisterGaussianRng_swigregister(BoxMullerMersenneTwisterGaussianRng)

class MoroInvCumulativeLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_MoroInvCumulativeLecuyerGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRng
    __del__ = lambda self: None
MoroInvCumulativeLecuyerGaussianRng_swigregister = _QuantLib.MoroInvCumulativeLecuyerGaussianRng_swigregister
MoroInvCumulativeLecuyerGaussianRng_swigregister(MoroInvCumulativeLecuyerGaussianRng)

class MoroInvCumulativeKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_MoroInvCumulativeKnuthGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.MoroInvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRng
    __del__ = lambda self: None
MoroInvCumulativeKnuthGaussianRng_swigregister = _QuantLib.MoroInvCumulativeKnuthGaussianRng_swigregister
MoroInvCumulativeKnuthGaussianRng_swigregister(MoroInvCumulativeKnuthGaussianRng)

class MoroInvCumulativeMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRng
    __del__ = lambda self: None
MoroInvCumulativeMersenneTwisterGaussianRng_swigregister = _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRng_swigregister
MoroInvCumulativeMersenneTwisterGaussianRng_swigregister(MoroInvCumulativeMersenneTwisterGaussianRng)

class InvCumulativeLecuyerGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_InvCumulativeLecuyerGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.InvCumulativeLecuyerGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRng
    __del__ = lambda self: None
InvCumulativeLecuyerGaussianRng_swigregister = _QuantLib.InvCumulativeLecuyerGaussianRng_swigregister
InvCumulativeLecuyerGaussianRng_swigregister(InvCumulativeLecuyerGaussianRng)

class InvCumulativeKnuthGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_InvCumulativeKnuthGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.InvCumulativeKnuthGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRng
    __del__ = lambda self: None
InvCumulativeKnuthGaussianRng_swigregister = _QuantLib.InvCumulativeKnuthGaussianRng_swigregister
InvCumulativeKnuthGaussianRng_swigregister(InvCumulativeKnuthGaussianRng)

class InvCumulativeMersenneTwisterGaussianRng(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_InvCumulativeMersenneTwisterGaussianRng(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRng_next(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRng
    __del__ = lambda self: None
InvCumulativeMersenneTwisterGaussianRng_swigregister = _QuantLib.InvCumulativeMersenneTwisterGaussianRng_swigregister
InvCumulativeMersenneTwisterGaussianRng_swigregister(InvCumulativeMersenneTwisterGaussianRng)

class GaussianRandomGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, rng):
        this = _QuantLib.new_GaussianRandomGenerator(rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.GaussianRandomGenerator_next(self)

    def nextValue(self):
        return _QuantLib.GaussianRandomGenerator_nextValue(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomGenerator
    __del__ = lambda self: None
GaussianRandomGenerator_swigregister = _QuantLib.GaussianRandomGenerator_swigregister
GaussianRandomGenerator_swigregister(GaussianRandomGenerator)

class HaltonRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimensionality, seed=0, randomStart=True, randomShift=False):
        this = _QuantLib.new_HaltonRsg(dimensionality, seed, randomStart, randomShift)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
HaltonRsg_swigregister = _QuantLib.HaltonRsg_swigregister
HaltonRsg_swigregister(HaltonRsg)

class SobolRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    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):
        this = _QuantLib.new_SobolRsg(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
SobolRsg_swigregister = _QuantLib.SobolRsg_swigregister
SobolRsg_swigregister(SobolRsg)

class SobolBrownianBridgeRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, factors, steps):
        this = _QuantLib.new_SobolBrownianBridgeRsg(factors, steps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
SobolBrownianBridgeRsg_swigregister = _QuantLib.SobolBrownianBridgeRsg_swigregister
SobolBrownianBridgeRsg_swigregister(SobolBrownianBridgeRsg)

class LecuyerUniformRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimensionality, rng):
        this = _QuantLib.new_LecuyerUniformRsg(dimensionality, rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.LecuyerUniformRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.LecuyerUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_LecuyerUniformRsg
    __del__ = lambda self: None
LecuyerUniformRsg_swigregister = _QuantLib.LecuyerUniformRsg_swigregister
LecuyerUniformRsg_swigregister(LecuyerUniformRsg)

class KnuthUniformRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimensionality, rng):
        this = _QuantLib.new_KnuthUniformRsg(dimensionality, rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.KnuthUniformRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.KnuthUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_KnuthUniformRsg
    __del__ = lambda self: None
KnuthUniformRsg_swigregister = _QuantLib.KnuthUniformRsg_swigregister
KnuthUniformRsg_swigregister(KnuthUniformRsg)

class MersenneTwisterUniformRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimensionality, rng):
        this = _QuantLib.new_MersenneTwisterUniformRsg(dimensionality, rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.MersenneTwisterUniformRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MersenneTwisterUniformRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MersenneTwisterUniformRsg
    __del__ = lambda self: None
MersenneTwisterUniformRsg_swigregister = _QuantLib.MersenneTwisterUniformRsg_swigregister
MersenneTwisterUniformRsg_swigregister(MersenneTwisterUniformRsg)

class UniformRandomSequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimensionality, rng):
        this = _QuantLib.new_UniformRandomSequenceGenerator(dimensionality, rng)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.UniformRandomSequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.UniformRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformRandomSequenceGenerator
    __del__ = lambda self: None
UniformRandomSequenceGenerator_swigregister = _QuantLib.UniformRandomSequenceGenerator_swigregister
UniformRandomSequenceGenerator_swigregister(UniformRandomSequenceGenerator)

class UniformLowDiscrepancySequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimensionality):
        this = _QuantLib.new_UniformLowDiscrepancySequenceGenerator(dimensionality)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.UniformLowDiscrepancySequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.UniformLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_UniformLowDiscrepancySequenceGenerator
    __del__ = lambda self: None
UniformLowDiscrepancySequenceGenerator_swigregister = _QuantLib.UniformLowDiscrepancySequenceGenerator_swigregister
UniformLowDiscrepancySequenceGenerator_swigregister(UniformLowDiscrepancySequenceGenerator)

class MoroInvCumulativeLecuyerGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_MoroInvCumulativeLecuyerGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeLecuyerGaussianRsg
    __del__ = lambda self: None
MoroInvCumulativeLecuyerGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeLecuyerGaussianRsg_swigregister
MoroInvCumulativeLecuyerGaussianRsg_swigregister(MoroInvCumulativeLecuyerGaussianRsg)

class MoroInvCumulativeKnuthGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_MoroInvCumulativeKnuthGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeKnuthGaussianRsg
    __del__ = lambda self: None
MoroInvCumulativeKnuthGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeKnuthGaussianRsg_swigregister
MoroInvCumulativeKnuthGaussianRsg_swigregister(MoroInvCumulativeKnuthGaussianRsg)

class MoroInvCumulativeMersenneTwisterGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_MoroInvCumulativeMersenneTwisterGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeMersenneTwisterGaussianRsg
    __del__ = lambda self: None
MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister
MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister(MoroInvCumulativeMersenneTwisterGaussianRsg)

class MoroInvCumulativeHaltonGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_MoroInvCumulativeHaltonGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeHaltonGaussianRsg
    __del__ = lambda self: None
MoroInvCumulativeHaltonGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeHaltonGaussianRsg_swigregister
MoroInvCumulativeHaltonGaussianRsg_swigregister(MoroInvCumulativeHaltonGaussianRsg)

class MoroInvCumulativeSobolGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_MoroInvCumulativeSobolGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.MoroInvCumulativeSobolGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.MoroInvCumulativeSobolGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_MoroInvCumulativeSobolGaussianRsg
    __del__ = lambda self: None
MoroInvCumulativeSobolGaussianRsg_swigregister = _QuantLib.MoroInvCumulativeSobolGaussianRsg_swigregister
MoroInvCumulativeSobolGaussianRsg_swigregister(MoroInvCumulativeSobolGaussianRsg)

class InvCumulativeLecuyerGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_InvCumulativeLecuyerGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.InvCumulativeLecuyerGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeLecuyerGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeLecuyerGaussianRsg
    __del__ = lambda self: None
InvCumulativeLecuyerGaussianRsg_swigregister = _QuantLib.InvCumulativeLecuyerGaussianRsg_swigregister
InvCumulativeLecuyerGaussianRsg_swigregister(InvCumulativeLecuyerGaussianRsg)

class InvCumulativeKnuthGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_InvCumulativeKnuthGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.InvCumulativeKnuthGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeKnuthGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeKnuthGaussianRsg
    __del__ = lambda self: None
InvCumulativeKnuthGaussianRsg_swigregister = _QuantLib.InvCumulativeKnuthGaussianRsg_swigregister
InvCumulativeKnuthGaussianRsg_swigregister(InvCumulativeKnuthGaussianRsg)

class InvCumulativeMersenneTwisterGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_InvCumulativeMersenneTwisterGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeMersenneTwisterGaussianRsg
    __del__ = lambda self: None
InvCumulativeMersenneTwisterGaussianRsg_swigregister = _QuantLib.InvCumulativeMersenneTwisterGaussianRsg_swigregister
InvCumulativeMersenneTwisterGaussianRsg_swigregister(InvCumulativeMersenneTwisterGaussianRsg)

class InvCumulativeHaltonGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_InvCumulativeHaltonGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.InvCumulativeHaltonGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeHaltonGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeHaltonGaussianRsg
    __del__ = lambda self: None
InvCumulativeHaltonGaussianRsg_swigregister = _QuantLib.InvCumulativeHaltonGaussianRsg_swigregister
InvCumulativeHaltonGaussianRsg_swigregister(InvCumulativeHaltonGaussianRsg)

class InvCumulativeSobolGaussianRsg(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_InvCumulativeSobolGaussianRsg(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.InvCumulativeSobolGaussianRsg_nextSequence(self)

    def dimension(self):
        return _QuantLib.InvCumulativeSobolGaussianRsg_dimension(self)
    __swig_destroy__ = _QuantLib.delete_InvCumulativeSobolGaussianRsg
    __del__ = lambda self: None
InvCumulativeSobolGaussianRsg_swigregister = _QuantLib.InvCumulativeSobolGaussianRsg_swigregister
InvCumulativeSobolGaussianRsg_swigregister(InvCumulativeSobolGaussianRsg)

class GaussianRandomSequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uniformSequenceGenerator):
        this = _QuantLib.new_GaussianRandomSequenceGenerator(uniformSequenceGenerator)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.GaussianRandomSequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.GaussianRandomSequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianRandomSequenceGenerator
    __del__ = lambda self: None
GaussianRandomSequenceGenerator_swigregister = _QuantLib.GaussianRandomSequenceGenerator_swigregister
GaussianRandomSequenceGenerator_swigregister(GaussianRandomSequenceGenerator)

class GaussianLowDiscrepancySequenceGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, u):
        this = _QuantLib.new_GaussianLowDiscrepancySequenceGenerator(u)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nextSequence(self):
        return _QuantLib.GaussianLowDiscrepancySequenceGenerator_nextSequence(self)

    def dimension(self):
        return _QuantLib.GaussianLowDiscrepancySequenceGenerator_dimension(self)
    __swig_destroy__ = _QuantLib.delete_GaussianLowDiscrepancySequenceGenerator
    __del__ = lambda self: None
GaussianLowDiscrepancySequenceGenerator_swigregister = _QuantLib.GaussianLowDiscrepancySequenceGenerator_swigregister
GaussianLowDiscrepancySequenceGenerator_swigregister(GaussianLowDiscrepancySequenceGenerator)


def getCovariance(volatilities, correlations):
    return _QuantLib.getCovariance(volatilities, correlations)
getCovariance = _QuantLib.getCovariance
class Path(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def value(self, 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
    __del__ = lambda self: None
Path_swigregister = _QuantLib.Path_swigregister
Path_swigregister(Path)

class SamplePath(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def weight(self):
        return _QuantLib.SamplePath_weight(self)
    __swig_destroy__ = _QuantLib.delete_SamplePath
    __del__ = lambda self: None
SamplePath_swigregister = _QuantLib.SamplePath_swigregister
SamplePath_swigregister(SamplePath)

class GaussianPathGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, length, steps, rsg, brownianBridge):
        this = _QuantLib.new_GaussianPathGenerator(process, length, steps, rsg, brownianBridge)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.GaussianPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.GaussianPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianPathGenerator
    __del__ = lambda self: None
GaussianPathGenerator_swigregister = _QuantLib.GaussianPathGenerator_swigregister
GaussianPathGenerator_swigregister(GaussianPathGenerator)

class GaussianSobolPathGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, length, steps, rsg, brownianBridge):
        this = _QuantLib.new_GaussianSobolPathGenerator(process, length, steps, rsg, brownianBridge)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.GaussianSobolPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.GaussianSobolPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianSobolPathGenerator
    __del__ = lambda self: None
GaussianSobolPathGenerator_swigregister = _QuantLib.GaussianSobolPathGenerator_swigregister
GaussianSobolPathGenerator_swigregister(GaussianSobolPathGenerator)

class MultiPath(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def assetNumber(self):
        return _QuantLib.MultiPath_assetNumber(self)

    def at(self, j):
        return _QuantLib.MultiPath_at(self, j)

    def __getitem__(self, i):
        return _QuantLib.MultiPath___getitem__(self, i)
    __swig_destroy__ = _QuantLib.delete_MultiPath
    __del__ = lambda self: None
MultiPath_swigregister = _QuantLib.MultiPath_swigregister
MultiPath_swigregister(MultiPath)

class SampleMultiPath(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

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

    def weight(self):
        return _QuantLib.SampleMultiPath_weight(self)
    __swig_destroy__ = _QuantLib.delete_SampleMultiPath
    __del__ = lambda self: None
SampleMultiPath_swigregister = _QuantLib.SampleMultiPath_swigregister
SampleMultiPath_swigregister(SampleMultiPath)

class GaussianMultiPathGenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, process, times, generator, brownianBridge=False):
        this = _QuantLib.new_GaussianMultiPathGenerator(process, times, generator, brownianBridge)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _QuantLib.GaussianMultiPathGenerator_next(self)

    def antithetic(self):
        return _QuantLib.GaussianMultiPathGenerator_antithetic(self)
    __swig_destroy__ = _QuantLib.delete_GaussianMultiPathGenerator
    __del__ = lambda self: None
GaussianMultiPathGenerator_swigregister = _QuantLib.GaussianMultiPathGenerator_swigregister
GaussianMultiPathGenerator_swigregister(GaussianMultiPathGenerator)

class BrownianBridge(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BrownianBridge(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
BrownianBridge_swigregister = _QuantLib.BrownianBridge_swigregister
BrownianBridge_swigregister(BrownianBridge)

class BoundaryCondition(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

    def __bool__(self):
        return _QuantLib.BoundaryCondition___bool__(self)
    NoSide = _QuantLib.BoundaryCondition_NoSide
    Upper = _QuantLib.BoundaryCondition_Upper
    Lower = _QuantLib.BoundaryCondition_Lower

    def __init__(self):
        this = _QuantLib.new_BoundaryCondition()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BoundaryCondition
    __del__ = lambda self: None
BoundaryCondition_swigregister = _QuantLib.BoundaryCondition_swigregister
BoundaryCondition_swigregister(BoundaryCondition)

class NeumannBC(BoundaryCondition):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, value, side):
        this = _QuantLib.new_NeumannBC(value, side)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_NeumannBC
    __del__ = lambda self: None
NeumannBC_swigregister = _QuantLib.NeumannBC_swigregister
NeumannBC_swigregister(NeumannBC)

class DirichletBC(BoundaryCondition):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, value, side):
        this = _QuantLib.new_DirichletBC(value, side)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DirichletBC
    __del__ = lambda self: None
DirichletBC_swigregister = _QuantLib.DirichletBC_swigregister
DirichletBC_swigregister(DirichletBC)

class TridiagonalOperator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, low, mid, high):
        this = _QuantLib.new_TridiagonalOperator(low, mid, high)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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)
    identity = staticmethod(_QuantLib.TridiagonalOperator_identity)

    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
    __del__ = lambda self: None
TridiagonalOperator_swigregister = _QuantLib.TridiagonalOperator_swigregister
TridiagonalOperator_swigregister(TridiagonalOperator)

def TridiagonalOperator_identity(size):
    return _QuantLib.TridiagonalOperator_identity(size)
TridiagonalOperator_identity = _QuantLib.TridiagonalOperator_identity

class DPlus(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        this = _QuantLib.new_DPlus(gridPoints, h)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DPlus
    __del__ = lambda self: None
DPlus_swigregister = _QuantLib.DPlus_swigregister
DPlus_swigregister(DPlus)

class DMinus(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        this = _QuantLib.new_DMinus(gridPoints, h)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DMinus
    __del__ = lambda self: None
DMinus_swigregister = _QuantLib.DMinus_swigregister
DMinus_swigregister(DMinus)

class DZero(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        this = _QuantLib.new_DZero(gridPoints, h)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DZero
    __del__ = lambda self: None
DZero_swigregister = _QuantLib.DZero_swigregister
DZero_swigregister(DZero)

class DPlusDMinus(TridiagonalOperator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, gridPoints, h):
        this = _QuantLib.new_DPlusDMinus(gridPoints, h)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_DPlusDMinus
    __del__ = lambda self: None
DPlusDMinus_swigregister = _QuantLib.DPlusDMinus_swigregister
DPlusDMinus_swigregister(DPlusDMinus)

class Discount(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_Discount()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Discount
    __del__ = lambda self: None
Discount_swigregister = _QuantLib.Discount_swigregister
Discount_swigregister(Discount)

class ZeroYield(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ZeroYield()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ZeroYield
    __del__ = lambda self: None
ZeroYield_swigregister = _QuantLib.ZeroYield_swigregister
ZeroYield_swigregister(ZeroYield)

class ForwardRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _QuantLib.new_ForwardRate()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_ForwardRate
    __del__ = lambda self: None
ForwardRate_swigregister = _QuantLib.ForwardRate_swigregister
ForwardRate_swigregister(ForwardRate)

class PiecewiseFlatForward(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseFlatForward(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def times(self):
        return _QuantLib.PiecewiseFlatForward_times(self)

    def nodes(self):
        return _QuantLib.PiecewiseFlatForward_nodes(self)
    __swig_destroy__ = _QuantLib.delete_PiecewiseFlatForward
    __del__ = lambda self: None
PiecewiseFlatForward_swigregister = _QuantLib.PiecewiseFlatForward_swigregister
PiecewiseFlatForward_swigregister(PiecewiseFlatForward)

class PiecewiseLinearForward(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseLinearForward(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseLinearForward_swigregister = _QuantLib.PiecewiseLinearForward_swigregister
PiecewiseLinearForward_swigregister(PiecewiseLinearForward)

class PiecewiseLinearZero(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseLinearZero(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseLinearZero_swigregister = _QuantLib.PiecewiseLinearZero_swigregister
PiecewiseLinearZero_swigregister(PiecewiseLinearZero)

class PiecewiseCubicZero(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseCubicZero(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseCubicZero_swigregister = _QuantLib.PiecewiseCubicZero_swigregister
PiecewiseCubicZero_swigregister(PiecewiseCubicZero)

class PiecewiseLogCubicDiscount(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_PiecewiseLogCubicDiscount(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
PiecewiseLogCubicDiscount_swigregister = _QuantLib.PiecewiseLogCubicDiscount_swigregister
PiecewiseLogCubicDiscount_swigregister(PiecewiseLogCubicDiscount)

class SampledCurve(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_SampledCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
SampledCurve_swigregister = _QuantLib.SampledCurve_swigregister
SampledCurve_swigregister(SampledCurve)

class Settings(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    instance = staticmethod(_QuantLib.Settings_instance)

    def getEvaluationDate(self):
        return _QuantLib.Settings_getEvaluationDate(self)

    def setEvaluationDate(self, 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)

    evaluationDate = property(getEvaluationDate,setEvaluationDate,None)
    includeReferenceDateCashFlows = property(None,includeReferenceDateEvents,None)
    includeReferenceDateEvents = property(None,includeReferenceDateEvents,None)
    includeTodaysCashFlows = property(None,includeTodaysCashFlows,None)

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

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

class Statistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def samples(self):
        return _QuantLib.Statistics_samples(self)

    def weightSum(self):
        return _QuantLib.Statistics_weightSum(self)

    def mean(self):
        return _QuantLib.Statistics_mean(self)

    def variance(self):
        return _QuantLib.Statistics_variance(self)

    def standardDeviation(self):
        return _QuantLib.Statistics_standardDeviation(self)

    def errorEstimate(self):
        return _QuantLib.Statistics_errorEstimate(self)

    def skewness(self):
        return _QuantLib.Statistics_skewness(self)

    def kurtosis(self):
        return _QuantLib.Statistics_kurtosis(self)

    def min(self):
        return _QuantLib.Statistics_min(self)

    def max(self):
        return _QuantLib.Statistics_max(self)

    def reset(self):
        return _QuantLib.Statistics_reset(self)

    def add(self, *args):
        return _QuantLib.Statistics_add(self, *args)

    def __init__(self):
        this = _QuantLib.new_Statistics()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Statistics
    __del__ = lambda self: None
Statistics_swigregister = _QuantLib.Statistics_swigregister
Statistics_swigregister(Statistics)

class IncrementalStatistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def samples(self):
        return _QuantLib.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):
        this = _QuantLib.new_IncrementalStatistics()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_IncrementalStatistics
    __del__ = lambda self: None
IncrementalStatistics_swigregister = _QuantLib.IncrementalStatistics_swigregister
IncrementalStatistics_swigregister(IncrementalStatistics)

class RiskStatistics(Statistics):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def semiVariance(self):
        return _QuantLib.RiskStatistics_semiVariance(self)

    def semiDeviation(self):
        return _QuantLib.RiskStatistics_semiDeviation(self)

    def downsideVariance(self):
        return _QuantLib.RiskStatistics_downsideVariance(self)

    def downsideDeviation(self):
        return _QuantLib.RiskStatistics_downsideDeviation(self)

    def regret(self, 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):
        this = _QuantLib.new_RiskStatistics()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_RiskStatistics
    __del__ = lambda self: None
RiskStatistics_swigregister = _QuantLib.RiskStatistics_swigregister
RiskStatistics_swigregister(RiskStatistics)

class MultipleStatistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimension):
        this = _QuantLib.new_MultipleStatistics(dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def samples(self):
        return _QuantLib.MultipleStatistics_samples(self)

    def weightSum(self):
        return _QuantLib.MultipleStatistics_weightSum(self)

    def mean(self):
        return _QuantLib.MultipleStatistics_mean(self)

    def variance(self):
        return _QuantLib.MultipleStatistics_variance(self)

    def standardDeviation(self):
        return _QuantLib.MultipleStatistics_standardDeviation(self)

    def errorEstimate(self):
        return _QuantLib.MultipleStatistics_errorEstimate(self)

    def skewness(self):
        return _QuantLib.MultipleStatistics_skewness(self)

    def kurtosis(self):
        return _QuantLib.MultipleStatistics_kurtosis(self)

    def min(self):
        return _QuantLib.MultipleStatistics_min(self)

    def max(self):
        return _QuantLib.MultipleStatistics_max(self)

    def covariance(self):
        return _QuantLib.MultipleStatistics_covariance(self)

    def correlation(self):
        return _QuantLib.MultipleStatistics_correlation(self)

    def reset(self):
        return _QuantLib.MultipleStatistics_reset(self)

    def add(self, *args):
        return _QuantLib.MultipleStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_MultipleStatistics
    __del__ = lambda self: None
MultipleStatistics_swigregister = _QuantLib.MultipleStatistics_swigregister
MultipleStatistics_swigregister(MultipleStatistics)

class SequenceStatistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimension):
        this = _QuantLib.new_SequenceStatistics(dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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

    def samples(self):
        return _QuantLib.SequenceStatistics_samples(self)

    def weightSum(self):
        return _QuantLib.SequenceStatistics_weightSum(self)

    def mean(self):
        return _QuantLib.SequenceStatistics_mean(self)

    def variance(self):
        return _QuantLib.SequenceStatistics_variance(self)

    def standardDeviation(self):
        return _QuantLib.SequenceStatistics_standardDeviation(self)

    def errorEstimate(self):
        return _QuantLib.SequenceStatistics_errorEstimate(self)

    def skewness(self):
        return _QuantLib.SequenceStatistics_skewness(self)

    def kurtosis(self):
        return _QuantLib.SequenceStatistics_kurtosis(self)

    def min(self):
        return _QuantLib.SequenceStatistics_min(self)

    def max(self):
        return _QuantLib.SequenceStatistics_max(self)

    def covariance(self):
        return _QuantLib.SequenceStatistics_covariance(self)

    def correlation(self):
        return _QuantLib.SequenceStatistics_correlation(self)

    def reset(self):
        return _QuantLib.SequenceStatistics_reset(self)

    def add(self, *args):
        return _QuantLib.SequenceStatistics_add(self, *args)
    __swig_destroy__ = _QuantLib.delete_SequenceStatistics
    __del__ = lambda self: None
SequenceStatistics_swigregister = _QuantLib.SequenceStatistics_swigregister
SequenceStatistics_swigregister(SequenceStatistics)

class MultipleIncrementalStatistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dimension):
        this = _QuantLib.new_MultipleIncrementalStatistics(dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
MultipleIncrementalStatistics_swigregister = _QuantLib.MultipleIncrementalStatistics_swigregister
MultipleIncrementalStatistics_swigregister(MultipleIncrementalStatistics)

class CapFloorTermVolatilityStructure(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def asObservable(self):
        return _QuantLib.CapFloorTermVolatilityStructure_asObservable(self)

    def __init__(self):
        this = _QuantLib.new_CapFloorTermVolatilityStructure()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolatilityStructure
    __del__ = lambda self: None

    def volatility(self, *args):
        return _QuantLib.CapFloorTermVolatilityStructure_volatility(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructure_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructure_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructure_allowsExtrapolation(self)
CapFloorTermVolatilityStructure_swigregister = _QuantLib.CapFloorTermVolatilityStructure_swigregister
CapFloorTermVolatilityStructure_swigregister(CapFloorTermVolatilityStructure)

class CapFloorTermVolatilityStructureHandle(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CapFloorTermVolatilityStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle___deref__(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
    __del__ = lambda self: None

    def volatility(self, *args):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_volatility(self, *args)

    def enableExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_enableExtrapolation(self)

    def disableExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_disableExtrapolation(self)

    def allowsExtrapolation(self):
        return _QuantLib.CapFloorTermVolatilityStructureHandle_allowsExtrapolation(self)
CapFloorTermVolatilityStructureHandle_swigregister = _QuantLib.CapFloorTermVolatilityStructureHandle_swigregister
CapFloorTermVolatilityStructureHandle_swigregister(CapFloorTermVolatilityStructureHandle)

class RelinkableCapFloorTermVolatilityStructureHandle(CapFloorTermVolatilityStructureHandle):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_RelinkableCapFloorTermVolatilityStructureHandle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def linkTo(self, arg2):
        return _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_linkTo(self, arg2)
    __swig_destroy__ = _QuantLib.delete_RelinkableCapFloorTermVolatilityStructureHandle
    __del__ = lambda self: None
RelinkableCapFloorTermVolatilityStructureHandle_swigregister = _QuantLib.RelinkableCapFloorTermVolatilityStructureHandle_swigregister
RelinkableCapFloorTermVolatilityStructureHandle_swigregister(RelinkableCapFloorTermVolatilityStructureHandle)

class CapFloorTermVolCurve(CapFloorTermVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CapFloorTermVolCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolCurve
    __del__ = lambda self: None
CapFloorTermVolCurve_swigregister = _QuantLib.CapFloorTermVolCurve_swigregister
CapFloorTermVolCurve_swigregister(CapFloorTermVolCurve)

class CapFloorTermVolSurface(CapFloorTermVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CapFloorTermVolSurface(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_CapFloorTermVolSurface
    __del__ = lambda self: None
CapFloorTermVolSurface_swigregister = _QuantLib.CapFloorTermVolSurface_swigregister
CapFloorTermVolSurface_swigregister(CapFloorTermVolSurface)

class StrippedOptionletBase(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

    def __init__(self):
        this = _QuantLib.new_StrippedOptionletBase()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_StrippedOptionletBase
    __del__ = lambda self: None

    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)
StrippedOptionletBase_swigregister = _QuantLib.StrippedOptionletBase_swigregister
StrippedOptionletBase_swigregister(StrippedOptionletBase)

class OptionletStripper1(StrippedOptionletBase):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        this = _QuantLib.new_OptionletStripper1(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
OptionletStripper1_swigregister = _QuantLib.OptionletStripper1_swigregister
OptionletStripper1_swigregister(OptionletStripper1)

class StrippedOptionletAdapter(OptionletVolatilityStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, stripper):
        this = _QuantLib.new_StrippedOptionletAdapter(stripper)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_StrippedOptionletAdapter
    __del__ = lambda self: None
StrippedOptionletAdapter_swigregister = _QuantLib.StrippedOptionletAdapter_swigregister
StrippedOptionletAdapter_swigregister(StrippedOptionletAdapter)

class Settlement(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Physical = _QuantLib.Settlement_Physical
    Cash = _QuantLib.Settlement_Cash

    def __init__(self):
        this = _QuantLib.new_Settlement()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Settlement
    __del__ = lambda self: None
Settlement_swigregister = _QuantLib.Settlement_swigregister
Settlement_swigregister(Settlement)

class Swaption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_Swaption(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Swaption
    __del__ = lambda self: None
Swaption_swigregister = _QuantLib.Swaption_swigregister
Swaption_swigregister(Swaption)

class NonstandardSwaption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_NonstandardSwaption(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calibrationBasket(self, standardSwapBase, swaptionVolatility, typeStr):
        return _QuantLib.NonstandardSwaption_calibrationBasket(self, standardSwapBase, swaptionVolatility, typeStr)
    __swig_destroy__ = _QuantLib.delete_NonstandardSwaption
    __del__ = lambda self: None
NonstandardSwaption_swigregister = _QuantLib.NonstandardSwaption_swigregister
NonstandardSwaption_swigregister(NonstandardSwaption)

class FloatFloatSwaption(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, simpleSwap, exercise):
        this = _QuantLib.new_FloatFloatSwaption(simpleSwap, exercise)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calibrationBasket(self, standardSwapBase, swaptionVolatility, typeStr):
        return _QuantLib.FloatFloatSwaption_calibrationBasket(self, standardSwapBase, swaptionVolatility, typeStr)

    def underlyingValue(self):
        return _QuantLib.FloatFloatSwaption_underlyingValue(self)
    __swig_destroy__ = _QuantLib.delete_FloatFloatSwaption
    __del__ = lambda self: None
FloatFloatSwaption_swigregister = _QuantLib.FloatFloatSwaption_swigregister
FloatFloatSwaption_swigregister(FloatFloatSwaption)

class BlackSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BlackSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def vega(self):
        return _QuantLib.BlackSwaptionEngine_vega(self)
    __swig_destroy__ = _QuantLib.delete_BlackSwaptionEngine
    __del__ = lambda self: None
BlackSwaptionEngine_swigregister = _QuantLib.BlackSwaptionEngine_swigregister
BlackSwaptionEngine_swigregister(BlackSwaptionEngine)

class BachelierSwaptionEngine(PricingEngine):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BachelierSwaptionEngine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_BachelierSwaptionEngine
    __del__ = lambda self: None
BachelierSwaptionEngine_swigregister = _QuantLib.BachelierSwaptionEngine_swigregister
BachelierSwaptionEngine_swigregister(BachelierSwaptionEngine)


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

def disableTracing():
    return _QuantLib.disableTracing()
disableTracing = _QuantLib.disableTracing
class ConstantEstimator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, size):
        this = _QuantLib.new_ConstantEstimator(size)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.ConstantEstimator_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_ConstantEstimator
    __del__ = lambda self: None
ConstantEstimator_swigregister = _QuantLib.ConstantEstimator_swigregister
ConstantEstimator_swigregister(ConstantEstimator)

class ParkinsonSigma(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        this = _QuantLib.new_ParkinsonSigma(yearFraction)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.ParkinsonSigma_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_ParkinsonSigma
    __del__ = lambda self: None
ParkinsonSigma_swigregister = _QuantLib.ParkinsonSigma_swigregister
ParkinsonSigma_swigregister(ParkinsonSigma)

class GarmanKlassSigma1(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        this = _QuantLib.new_GarmanKlassSigma1(yearFraction, marketOpenFraction)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma1_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma1
    __del__ = lambda self: None
GarmanKlassSigma1_swigregister = _QuantLib.GarmanKlassSigma1_swigregister
GarmanKlassSigma1_swigregister(GarmanKlassSigma1)

class GarmanKlassSigma3(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        this = _QuantLib.new_GarmanKlassSigma3(yearFraction, marketOpenFraction)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma3_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma3
    __del__ = lambda self: None
GarmanKlassSigma3_swigregister = _QuantLib.GarmanKlassSigma3_swigregister
GarmanKlassSigma3_swigregister(GarmanKlassSigma3)

class GarmanKlassSigma4(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        this = _QuantLib.new_GarmanKlassSigma4(yearFraction)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma4_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma4
    __del__ = lambda self: None
GarmanKlassSigma4_swigregister = _QuantLib.GarmanKlassSigma4_swigregister
GarmanKlassSigma4_swigregister(GarmanKlassSigma4)

class GarmanKlassSigma5(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, yearFraction):
        this = _QuantLib.new_GarmanKlassSigma5(yearFraction)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma5_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma5
    __del__ = lambda self: None
GarmanKlassSigma5_swigregister = _QuantLib.GarmanKlassSigma5_swigregister
GarmanKlassSigma5_swigregister(GarmanKlassSigma5)

class GarmanKlassSigma6(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, yearFraction, marketOpenFraction):
        this = _QuantLib.new_GarmanKlassSigma6(yearFraction, marketOpenFraction)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate(self, arg2):
        return _QuantLib.GarmanKlassSigma6_calculate(self, arg2)
    __swig_destroy__ = _QuantLib.delete_GarmanKlassSigma6
    __del__ = lambda self: None
GarmanKlassSigma6_swigregister = _QuantLib.GarmanKlassSigma6_swigregister
GarmanKlassSigma6_swigregister(GarmanKlassSigma6)

class ZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
ZeroCurve_swigregister = _QuantLib.ZeroCurve_swigregister
ZeroCurve_swigregister(ZeroCurve)

class LogLinearZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_LogLinearZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
LogLinearZeroCurve_swigregister = _QuantLib.LogLinearZeroCurve_swigregister
LogLinearZeroCurve_swigregister(LogLinearZeroCurve)

class CubicZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_CubicZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CubicZeroCurve_swigregister = _QuantLib.CubicZeroCurve_swigregister
CubicZeroCurve_swigregister(CubicZeroCurve)

class LogCubicZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_LogCubicZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
LogCubicZeroCurve_swigregister = _QuantLib.LogCubicZeroCurve_swigregister
LogCubicZeroCurve_swigregister(LogCubicZeroCurve)

class ForwardFlatZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_ForwardFlatZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def times(self):
        return _QuantLib.ForwardFlatZeroCurve_times(self)

    def data(self):
        return _QuantLib.ForwardFlatZeroCurve_data(self)

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

    def zeroRates(self):
        return _QuantLib.ForwardFlatZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.ForwardFlatZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_ForwardFlatZeroCurve
    __del__ = lambda self: None
ForwardFlatZeroCurve_swigregister = _QuantLib.ForwardFlatZeroCurve_swigregister
ForwardFlatZeroCurve_swigregister(ForwardFlatZeroCurve)

class BackwardFlatZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_BackwardFlatZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def times(self):
        return _QuantLib.BackwardFlatZeroCurve_times(self)

    def data(self):
        return _QuantLib.BackwardFlatZeroCurve_data(self)

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

    def zeroRates(self):
        return _QuantLib.BackwardFlatZeroCurve_zeroRates(self)

    def nodes(self):
        return _QuantLib.BackwardFlatZeroCurve_nodes(self)
    __swig_destroy__ = _QuantLib.delete_BackwardFlatZeroCurve
    __del__ = lambda self: None
BackwardFlatZeroCurve_swigregister = _QuantLib.BackwardFlatZeroCurve_swigregister
BackwardFlatZeroCurve_swigregister(BackwardFlatZeroCurve)

class MonotonicCubicZeroCurve(YieldTermStructure):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_MonotonicCubicZeroCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
MonotonicCubicZeroCurve_swigregister = _QuantLib.MonotonicCubicZeroCurve_swigregister
MonotonicCubicZeroCurve_swigregister(MonotonicCubicZeroCurve)


def as_zerocurve(curve):
    return _QuantLib.as_zerocurve(curve)
as_zerocurve = _QuantLib.as_zerocurve
class Forward(Instrument):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    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)

    def __init__(self):
        this = _QuantLib.new_Forward()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _QuantLib.delete_Forward
    __del__ = lambda self: None
Forward_swigregister = _QuantLib.Forward_swigregister
Forward_swigregister(Forward)

class FixedRateBondForward(Forward):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _QuantLib.new_FixedRateBondForward(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def forwardPrice(self):
        return _QuantLib.FixedRateBondForward_forwardPrice(self)

    def cleanForwardPrice(self):
        return _QuantLib.FixedRateBondForward_cleanForwardPrice(self)

    def spotIncome(self, incomeDiscountCurve):
        return _QuantLib.FixedRateBondForward_spotIncome(self, incomeDiscountCurve)

    def spotValue(self):
        return _QuantLib.FixedRateBondForward_spotValue(self)
    __swig_destroy__ = _QuantLib.delete_FixedRateBondForward
    __del__ = lambda self: None
FixedRateBondForward_swigregister = _QuantLib.FixedRateBondForward_swigregister
FixedRateBondForward_swigregister(FixedRateBondForward)



